1/** 2 * Copyright (c) Tiny Technologies, Inc. All rights reserved. 3 * Licensed under the LGPL or a commercial license. 4 * For LGPL see License.txt in the project root for license information. 5 * For commercial licenses see https://www.tiny.cloud/ 6 * 7 * Version: 5.8.1 (2021-05-20) 8 */ 9(function () { 10 'use strict'; 11 12 var typeOf = function (x) { 13 var t = typeof x; 14 if (x === null) { 15 return 'null'; 16 } else if (t === 'object' && (Array.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'Array')) { 17 return 'array'; 18 } else if (t === 'object' && (String.prototype.isPrototypeOf(x) || x.constructor && x.constructor.name === 'String')) { 19 return 'string'; 20 } else { 21 return t; 22 } 23 }; 24 var isType = function (type) { 25 return function (value) { 26 return typeOf(value) === type; 27 }; 28 }; 29 var isSimpleType = function (type) { 30 return function (value) { 31 return typeof value === type; 32 }; 33 }; 34 var eq = function (t) { 35 return function (a) { 36 return t === a; 37 }; 38 }; 39 var isString = isType('string'); 40 var isObject = isType('object'); 41 var isArray = isType('array'); 42 var isBoolean = isSimpleType('boolean'); 43 var isUndefined = eq(undefined); 44 var isNullable = function (a) { 45 return a === null || a === undefined; 46 }; 47 var isNonNullable = function (a) { 48 return !isNullable(a); 49 }; 50 var isFunction = isSimpleType('function'); 51 var isNumber = isSimpleType('number'); 52 var isArrayOf = function (value, pred) { 53 if (isArray(value)) { 54 for (var i = 0, len = value.length; i < len; ++i) { 55 if (!pred(value[i])) { 56 return false; 57 } 58 } 59 return true; 60 } 61 return false; 62 }; 63 64 var noop = function () { 65 }; 66 var noarg = function (f) { 67 return function () { 68 return f(); 69 }; 70 }; 71 var compose = function (fa, fb) { 72 return function () { 73 var args = []; 74 for (var _i = 0; _i < arguments.length; _i++) { 75 args[_i] = arguments[_i]; 76 } 77 return fa(fb.apply(null, args)); 78 }; 79 }; 80 var compose1 = function (fbc, fab) { 81 return function (a) { 82 return fbc(fab(a)); 83 }; 84 }; 85 var constant = function (value) { 86 return function () { 87 return value; 88 }; 89 }; 90 var identity = function (x) { 91 return x; 92 }; 93 function curry(fn) { 94 var initialArgs = []; 95 for (var _i = 1; _i < arguments.length; _i++) { 96 initialArgs[_i - 1] = arguments[_i]; 97 } 98 return function () { 99 var restArgs = []; 100 for (var _i = 0; _i < arguments.length; _i++) { 101 restArgs[_i] = arguments[_i]; 102 } 103 var all = initialArgs.concat(restArgs); 104 return fn.apply(null, all); 105 }; 106 } 107 var not = function (f) { 108 return function (t) { 109 return !f(t); 110 }; 111 }; 112 var die = function (msg) { 113 return function () { 114 throw new Error(msg); 115 }; 116 }; 117 var never = constant(false); 118 var always = constant(true); 119 120 var global$1 = tinymce.util.Tools.resolve('tinymce.ThemeManager'); 121 122 var __assign = function () { 123 __assign = Object.assign || function __assign(t) { 124 for (var s, i = 1, n = arguments.length; i < n; i++) { 125 s = arguments[i]; 126 for (var p in s) 127 if (Object.prototype.hasOwnProperty.call(s, p)) 128 t[p] = s[p]; 129 } 130 return t; 131 }; 132 return __assign.apply(this, arguments); 133 }; 134 function __rest(s, e) { 135 var t = {}; 136 for (var p in s) 137 if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) 138 t[p] = s[p]; 139 if (s != null && typeof Object.getOwnPropertySymbols === 'function') 140 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { 141 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) 142 t[p[i]] = s[p[i]]; 143 } 144 return t; 145 } 146 function __spreadArrays() { 147 for (var s = 0, i = 0, il = arguments.length; i < il; i++) 148 s += arguments[i].length; 149 for (var r = Array(s), k = 0, i = 0; i < il; i++) 150 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 151 r[k] = a[j]; 152 return r; 153 } 154 155 var none = function () { 156 return NONE; 157 }; 158 var NONE = function () { 159 var eq = function (o) { 160 return o.isNone(); 161 }; 162 var call = function (thunk) { 163 return thunk(); 164 }; 165 var id = function (n) { 166 return n; 167 }; 168 var me = { 169 fold: function (n, _s) { 170 return n(); 171 }, 172 is: never, 173 isSome: never, 174 isNone: always, 175 getOr: id, 176 getOrThunk: call, 177 getOrDie: function (msg) { 178 throw new Error(msg || 'error: getOrDie called on none.'); 179 }, 180 getOrNull: constant(null), 181 getOrUndefined: constant(undefined), 182 or: id, 183 orThunk: call, 184 map: none, 185 each: noop, 186 bind: none, 187 exists: never, 188 forall: always, 189 filter: none, 190 equals: eq, 191 equals_: eq, 192 toArray: function () { 193 return []; 194 }, 195 toString: constant('none()') 196 }; 197 return me; 198 }(); 199 var some = function (a) { 200 var constant_a = constant(a); 201 var self = function () { 202 return me; 203 }; 204 var bind = function (f) { 205 return f(a); 206 }; 207 var me = { 208 fold: function (n, s) { 209 return s(a); 210 }, 211 is: function (v) { 212 return a === v; 213 }, 214 isSome: always, 215 isNone: never, 216 getOr: constant_a, 217 getOrThunk: constant_a, 218 getOrDie: constant_a, 219 getOrNull: constant_a, 220 getOrUndefined: constant_a, 221 or: self, 222 orThunk: self, 223 map: function (f) { 224 return some(f(a)); 225 }, 226 each: function (f) { 227 f(a); 228 }, 229 bind: bind, 230 exists: bind, 231 forall: bind, 232 filter: function (f) { 233 return f(a) ? me : NONE; 234 }, 235 toArray: function () { 236 return [a]; 237 }, 238 toString: function () { 239 return 'some(' + a + ')'; 240 }, 241 equals: function (o) { 242 return o.is(a); 243 }, 244 equals_: function (o, elementEq) { 245 return o.fold(never, function (b) { 246 return elementEq(a, b); 247 }); 248 } 249 }; 250 return me; 251 }; 252 var from = function (value) { 253 return value === null || value === undefined ? NONE : some(value); 254 }; 255 var Optional = { 256 some: some, 257 none: none, 258 from: from 259 }; 260 261 var nativeSlice = Array.prototype.slice; 262 var nativeIndexOf = Array.prototype.indexOf; 263 var nativePush = Array.prototype.push; 264 var rawIndexOf = function (ts, t) { 265 return nativeIndexOf.call(ts, t); 266 }; 267 var indexOf = function (xs, x) { 268 var r = rawIndexOf(xs, x); 269 return r === -1 ? Optional.none() : Optional.some(r); 270 }; 271 var contains = function (xs, x) { 272 return rawIndexOf(xs, x) > -1; 273 }; 274 var exists = function (xs, pred) { 275 for (var i = 0, len = xs.length; i < len; i++) { 276 var x = xs[i]; 277 if (pred(x, i)) { 278 return true; 279 } 280 } 281 return false;
282 }; 283 var range = function (num, f) { 284 var r = []; 285 for (var i = 0; i < num; i++) { 286 r.push(f(i)); 287 } 288 return r; 289 }; 290 var chunk = function (array, size) { 291 var r = []; 292 for (var i = 0; i < array.length; i += size) { 293 var s = nativeSlice.call(array, i, i + size); 294 r.push(s); 295 } 296 return r; 297 }; 298 var map = function (xs, f) { 299 var len = xs.length; 300 var r = new Array(len); 301 for (var i = 0; i < len; i++) { 302 var x = xs[i]; 303 r[i] = f(x, i); 304 } 305 return r; 306 }; 307 var each = function (xs, f) { 308 for (var i = 0, len = xs.length; i < len; i++) { 309 var x = xs[i]; 310 f(x, i); 311 } 312 }; 313 var eachr = function (xs, f) { 314 for (var i = xs.length - 1; i >= 0; i--) { 315 var x = xs[i]; 316 f(x, i); 317 } 318 }; 319 var partition = function (xs, pred) { 320 var pass = []; 321 var fail = []; 322 for (var i = 0, len = xs.length; i < len; i++) { 323 var x = xs[i]; 324 var arr = pred(x, i) ? pass : fail; 325 arr.push(x); 326 } 327 return { 328 pass: pass, 329 fail: fail 330 }; 331 }; 332 var filter = function (xs, pred) { 333 var r = []; 334 for (var i = 0, len = xs.length; i < len; i++) { 335 var x = xs[i]; 336 if (pred(x, i)) { 337 r.push(x); 338 } 339 } 340 return r; 341 }; 342 var foldr = function (xs, f, acc) { 343 eachr(xs, function (x) { 344 acc = f(acc, x); 345 }); 346 return acc; 347 }; 348 var foldl = function (xs, f, acc) { 349 each(xs, function (x) { 350 acc = f(acc, x); 351 }); 352 return acc; 353 }; 354 var findUntil = function (xs, pred, until) { 355 for (var i = 0, len = xs.length; i < len; i++) { 356 var x = xs[i]; 357 if (pred(x, i)) { 358 return Optional.some(x); 359 } else if (until(x, i)) { 360 break; 361 } 362 } 363 return Optional.none(); 364 }; 365 var find = function (xs, pred) { 366 return findUntil(xs, pred, never); 367 }; 368 var findIndex = function (xs, pred) { 369 for (var i = 0, len = xs.length; i < len; i++) { 370 var x = xs[i]; 371 if (pred(x, i)) { 372 return Optional.some(i); 373 } 374 } 375 return Optional.none(); 376 }; 377 var flatten = function (xs) { 378 var r = []; 379 for (var i = 0, len = xs.length; i < len; ++i) { 380 if (!isArray(xs[i])) { 381 throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs); 382 } 383 nativePush.apply(r, xs[i]); 384 } 385 return r; 386 }; 387 var bind = function (xs, f) { 388 return flatten(map(xs, f)); 389 }; 390 var forall = function (xs, pred) { 391 for (var i = 0, len = xs.length; i < len; ++i) { 392 var x = xs[i]; 393 if (pred(x, i) !== true) { 394 return false; 395 } 396 } 397 return true; 398 }; 399 var reverse = function (xs) { 400 var r = nativeSlice.call(xs, 0); 401 r.reverse(); 402 return r; 403 }; 404 var difference = function (a1, a2) { 405 return filter(a1, function (x) { 406 return !contains(a2, x); 407 }); 408 }; 409 var mapToObject = function (xs, f) { 410 var r = {}; 411 for (var i = 0, len = xs.length; i < len; i++) { 412 var x = xs[i]; 413 r[String(x)] = f(x, i); 414 } 415 return r; 416 }; 417 var sort = function (xs, comparator) { 418 var copy = nativeSlice.call(xs, 0); 419 copy.sort(comparator); 420 return copy; 421 }; 422 var get = function (xs, i) { 423 return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none(); 424 }; 425 var head = function (xs) { 426 return get(xs, 0); 427 }; 428 var last = function (xs) { 429 return get(xs, xs.length - 1); 430 }; 431 var from$1 = isFunction(Array.from) ? Array.from : function (x) { 432 return nativeSlice.call(x); 433 }; 434 var findMap = function (arr, f) { 435 for (var i = 0; i < arr.length; i++) { 436 var r = f(arr[i], i); 437 if (r.isSome()) { 438 return r; 439 } 440 } 441 return Optional.none(); 442 }; 443 444 var value = function (o) { 445 var is = function (v) { 446 return o === v; 447 }; 448 var or = function (_opt) { 449 return value(o); 450 }; 451 var orThunk = function (_f) { 452 return value(o); 453 }; 454 var map = function (f) { 455 return value(f(o)); 456 }; 457 var mapError = function (_f) { 458 return value(o); 459 }; 460 var each = function (f) { 461 f(o); 462 }; 463 var bind = function (f) { 464 return f(o); 465 }; 466 var fold = function (_, onValue) { 467 return onValue(o); 468 }; 469 var exists = function (f) { 470 return f(o); 471 }; 472 var forall = function (f) { 473 return f(o); 474 }; 475 var toOptional = function () { 476 return Optional.some(o); 477 }; 478 return { 479 is: is, 480 isValue: always, 481 isError: never, 482 getOr: constant(o), 483 getOrThunk: constant(o), 484 getOrDie: constant(o), 485 or: or, 486 orThunk: orThunk, 487 fold: fold, 488 map: map, 489 mapError: mapError, 490 each: each, 491 bind: bind, 492 exists: exists, 493 forall: forall, 494 toOptional: toOptional 495 }; 496 }; 497 var error = function (message) { 498 var getOrThunk = function (f) { 499 return f(); 500 }; 501 var getOrDie = function () { 502 return die(String(message))(); 503 }; 504 var or = function (opt) { 505 return opt; 506 }; 507 var orThunk = function (f) { 508 return f(); 509 }; 510 var map = function (_f) { 511 return error(message); 512 }; 513 var mapError = function (f) { 514 return error(f(message)); 515 }; 516 var bind = function (_f) { 517 return error(message); 518 }; 519 var fold = function (onError, _) { 520 return onError(message); 521 }; 522 return { 523 is: never, 524 isValue: never, 525 isError: always, 526 getOr: identity, 527 getOrThunk: getOrThunk, 528 getOrDie: getOrDie, 529 or: or, 530 orThunk: orThunk, 531 fold: fold, 532 map: map, 533 mapError: mapError, 534 each: noop, 535 bind: bind, 536 exists: never, 537 forall: always, 538 toOptional: Optional.none 539 }; 540 }; 541 var fromOption = function (opt, err) { 542 return opt.fold(function () { 543 return error(err); 544 }, value); 545 }; 546 var Result = { 547 value: value, 548 error: error, 549 fromOption: fromOption 550 }; 551 552 var SimpleResultType; 553 (function (SimpleResultType) { 554 SimpleResultType[SimpleResultType['Error'] = 0] = 'Error'; 555 SimpleResultType[SimpleResultType['Value'] = 1] = 'Value'; 556 }(SimpleResultType || (SimpleResultType = {}))); 557 var fold = function (res, onError, onValue) { 558 return res.stype === SimpleResultType.Error ? onError(res.serror) : onValue(res.svalue); 559 }; 560 var partition$1 = function (results) { 561 var values = []; 562 var errors = []; 563 each(results, function (obj) { 564 fold(obj, function (err) { 565 return errors.push(err); 566 }, function (val) { 567 return values.push(val); 568 }); 569 }); 570 return { 571 values: values, 572 errors: errors 573 }; 574 }; 575 var mapError = function (res, f) { 576 if (res.stype === SimpleResultType.Error) { 577 return { 578 stype: SimpleResultType.Error, 579 serror: f(res.serror) 580 }; 581 } else { 582 return res; 583 } 584 }; 585 var map$1 = function (res, f) { 586 if (res.stype === SimpleResultType.Value) { 587 return { 588 stype: SimpleResultType.Value, 589 svalue: f(res.svalue) 590 }; 591 } else { 592 return res; 593 } 594 }; 595 var bind$1 = function (res, f) { 596 if (res.stype === SimpleResultType.Value) { 597 return f(res.svalue); 598 } else { 599 return res; 600 } 601 }; 602 var bindError = function (res, f) { 603 if (res.stype === SimpleResultType.Error) { 604 return f(res.serror); 605 } else { 606 return res; 607 } 608 }; 609 var svalue = function (v) { 610 return { 611 stype: SimpleResultType.Value, 612 svalue: v 613 }; 614 }; 615 var serror = function (e) { 616 return { 617 stype: SimpleResultType.Error, 618 serror: e 619 }; 620 }; 621 var toResult = function (res) { 622 return fold(res, Result.error, Result.value); 623 }; 624 var fromResult = function (res) { 625 return res.fold(serror, svalue); 626 }; 627 var SimpleResult = { 628 fromResult: fromResult, 629 toResult: toResult, 630 svalue: svalue, 631 partition: partition$1, 632 serror: serror, 633 bind: bind$1, 634 bindError: bindError, 635 map: map$1, 636 mapError: mapError, 637 fold: fold 638 }; 639 640 var keys = Object.keys; 641 var hasOwnProperty = Object.hasOwnProperty; 642 var each$1 = function (obj, f) { 643 var props = keys(obj); 644 for (var k = 0, len = props.length; k < len; k++) { 645 var i = props[k]; 646 var x = obj[i]; 647 f(x, i); 648 } 649 }; 650 var map$2 = function (obj, f) { 651 return tupleMap(obj, function (x, i) { 652 return { 653 k: i, 654 v: f(x, i) 655 }; 656 }); 657 }; 658 var tupleMap = function (obj, f) { 659 var r = {}; 660 each$1(obj, function (x, i) { 661 var tuple = f(x, i); 662 r[tuple.k] = tuple.v; 663 }); 664 return r; 665 }; 666 var objAcc = function (r) { 667 return function (x, i) { 668 r[i] = x; 669 }; 670 }; 671 var internalFilter = function (obj, pred, onTrue, onFalse) { 672 var r = {}; 673 each$1(obj, function (x, i) { 674 (pred(x, i) ? onTrue : onFalse)(x, i); 675 }); 676 return r; 677 }; 678 var filter$1 = function (obj, pred) { 679 var t = {}; 680 internalFilter(obj, pred, objAcc(t), noop); 681 return t; 682 }; 683 var mapToArray = function (obj, f) { 684 var r = []; 685 each$1(obj, function (value, name) { 686 r.push(f(value, name)); 687 }); 688 return r; 689 }; 690 var find$1 = function (obj, pred) { 691 var props = keys(obj); 692 for (var k = 0, len = props.length; k < len; k++) { 693 var i = props[k]; 694 var x = obj[i]; 695 if (pred(x, i, obj)) { 696 return Optional.some(x); 697 } 698 } 699 return Optional.none(); 700 }; 701 var values = function (obj) { 702 return mapToArray(obj, function (v) { 703 return v; 704 }); 705 }; 706 var get$1 = function (obj, key) { 707 return has(obj, key) ? Optional.from(obj[key]) : Optional.none(); 708 }; 709 var has = function (obj, key) { 710 return hasOwnProperty.call(obj, key); 711 }; 712 var hasNonNullableKey = function (obj, key) { 713 return has(obj, key) && obj[key] !== undefined && obj[key] !== null; 714 }; 715 716 var generate = function (cases) { 717 if (!isArray(cases)) { 718 throw new Error('cases must be an array'); 719 } 720 if (cases.length === 0) { 721 throw new Error('there must be at least one case'); 722 } 723 var constructors = []; 724 var adt = {}; 725 each(cases, function (acase, count) { 726 var keys$1 = keys(acase); 727 if (keys$1.length !== 1) { 728 throw new Error('one and only one name per case'); 729 } 730 var key = keys$1[0]; 731 var value = acase[key]; 732 if (adt[key] !== undefined) { 733 throw new Error('duplicate key detected:' + key); 734 } else if (key === 'cata') {
735 throw new Error('cannot have a case named cata (sorry)'); 736 } else if (!isArray(value)) { 737 throw new Error('case arguments must be an array'); 738 } 739 constructors.push(key); 740 adt[key] = function () { 741 var args = []; 742 for (var _i = 0; _i < arguments.length; _i++) { 743 args[_i] = arguments[_i]; 744 } 745 var argLength = args.length; 746 if (argLength !== value.length) { 747 throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength); 748 } 749 var match = function (branches) { 750 var branchKeys = keys(branches); 751 if (constructors.length !== branchKeys.length) { 752 throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(',')); 753 } 754 var allReqd = forall(constructors, function (reqKey) { 755 return contains(branchKeys, reqKey); 756 }); 757 if (!allReqd) { 758 throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', ')); 759 } 760 return branches[key].apply(null, args); 761 }; 762 return { 763 fold: function () { 764 var foldArgs = []; 765 for (var _i = 0; _i < arguments.length; _i++) { 766 foldArgs[_i] = arguments[_i]; 767 } 768 if (foldArgs.length !== cases.length) { 769 throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length); 770 } 771 var target = foldArgs[count]; 772 return target.apply(null, args); 773 }, 774 match: match, 775 log: function (label) { 776 console.log(label, { 777 constructors: constructors, 778 constructor: key, 779 params: args 780 }); 781 } 782 }; 783 }; 784 }); 785 return adt; 786 }; 787 var Adt = { generate: generate }; 788 789 var hasOwnProperty$1 = Object.prototype.hasOwnProperty; 790 var shallow = function (old, nu) { 791 return nu; 792 }; 793 var deep = function (old, nu) { 794 var bothObjects = isObject(old) && isObject(nu); 795 return bothObjects ? deepMerge(old, nu) : nu; 796 }; 797 var baseMerge = function (merger) { 798 return function () { 799 var objects = []; 800 for (var _i = 0; _i < arguments.length; _i++) { 801 objects[_i] = arguments[_i]; 802 } 803 if (objects.length === 0) { 804 throw new Error('Can\'t merge zero objects'); 805 } 806 var ret = {}; 807 for (var j = 0; j < objects.length; j++) { 808 var curObject = objects[j]; 809 for (var key in curObject) { 810 if (hasOwnProperty$1.call(curObject, key)) { 811 ret[key] = merger(ret[key], curObject[key]); 812 } 813 } 814 } 815 return ret; 816 }; 817 }; 818 var deepMerge = baseMerge(deep); 819 var merge = baseMerge(shallow); 820 821 var cached = function (f) { 822 var called = false; 823 var r; 824 return function () { 825 var args = []; 826 for (var _i = 0; _i < arguments.length; _i++) { 827 args[_i] = arguments[_i]; 828 } 829 if (!called) { 830 called = true; 831 r = f.apply(null, args); 832 } 833 return r; 834 }; 835 }; 836 837 var adt = Adt.generate([ 838 { strict: [] }, 839 { defaultedThunk: ['fallbackThunk'] }, 840 { asOption: [] }, 841 { asDefaultedOptionThunk: ['fallbackThunk'] }, 842 { mergeWithThunk: ['baseThunk'] } 843 ]); 844 var defaulted = function (fallback) { 845 return adt.defaultedThunk(constant(fallback)); 846 }; 847 var mergeWith = function (base) { 848 return adt.mergeWithThunk(constant(base)); 849 }; 850 var strict = adt.strict; 851 var asOption = adt.asOption; 852 var defaultedThunk = adt.defaultedThunk; 853 var asDefaultedOptionThunk = adt.asDefaultedOptionThunk; 854 var mergeWithThunk = adt.mergeWithThunk; 855 856 var comparison = Adt.generate([ 857 { 858 bothErrors: [ 859 'error1', 860 'error2' 861 ] 862 }, 863 { 864 firstError: [ 865 'error1', 866 'value2' 867 ] 868 }, 869 { 870 secondError: [ 871 'value1', 872 'error2' 873 ] 874 }, 875 { 876 bothValues: [ 877 'value1', 878 'value2' 879 ] 880 } 881 ]); 882 var partition$2 = function (results) { 883 var errors = []; 884 var values = []; 885 each(results, function (result) { 886 result.fold(function (err) { 887 errors.push(err); 888 }, function (value) { 889 values.push(value); 890 }); 891 }); 892 return { 893 errors: errors, 894 values: values 895 }; 896 }; 897 898 var exclude = function (obj, fields) { 899 var r = {}; 900 each$1(obj, function (v, k) { 901 if (!contains(fields, k)) { 902 r[k] = v; 903 } 904 }); 905 return r; 906 }; 907 908 var wrap = function (key, value) { 909 var _a; 910 return _a = {}, _a[key] = value, _a; 911 }; 912 var wrapAll = function (keyvalues) { 913 var r = {}; 914 each(keyvalues, function (kv) { 915 r[kv.key] = kv.value; 916 }); 917 return r; 918 }; 919 920 var exclude$1 = function (obj, fields) { 921 return exclude(obj, fields); 922 }; 923 var wrap$1 = function (key, value) { 924 return wrap(key, value); 925 }; 926 var wrapAll$1 = function (keyvalues) { 927 return wrapAll(keyvalues); 928 }; 929 var mergeValues = function (values, base) {
930 return values.length === 0 ? Result.value(base) : Result.value(deepMerge(base, merge.apply(undefined, values))); 931 }; 932 var mergeErrors = function (errors) { 933 return Result.error(flatten(errors)); 934 }; 935 var consolidate = function (objs, base) { 936 var partitions = partition$2(objs); 937 return partitions.errors.length > 0 ? mergeErrors(partitions.errors) : mergeValues(partitions.values, base); 938 }; 939 940 var mergeValues$1 = function (values, base) { 941 return values.length > 0 ? SimpleResult.svalue(deepMerge(base, merge.apply(undefined, values))) : SimpleResult.svalue(base); 942 }; 943 var mergeErrors$1 = function (errors) { 944 return compose(SimpleResult.serror, flatten)(errors); 945 }; 946 var consolidateObj = function (objects, base) { 947 var partition = SimpleResult.partition(objects); 948 return partition.errors.length > 0 ? mergeErrors$1(partition.errors) : mergeValues$1(partition.values, base); 949 }; 950 var consolidateArr = function (objects) { 951 var partitions = SimpleResult.partition(objects); 952 return partitions.errors.length > 0 ? mergeErrors$1(partitions.errors) : SimpleResult.svalue(partitions.values); 953 }; 954 var ResultCombine = { 955 consolidateObj: consolidateObj, 956 consolidateArr: consolidateArr 957 }; 958 959 var formatObj = function (input) { 960 return isObject(input) && keys(input).length > 100 ? ' removed due to size' : JSON.stringify(input, null, 2); 961 }; 962 var formatErrors = function (errors) { 963 var es = errors.length > 10 ? errors.slice(0, 10).concat([{ 964 path: [], 965 getErrorInfo: function () { 966 return '... (only showing first ten failures)'; 967 } 968 }]) : errors; 969 return map(es, function (e) { 970 return 'Failed path: (' + e.path.join(' > ') + ')\n' + e.getErrorInfo(); 971 }); 972 }; 973 974 var nu = function (path, getErrorInfo) { 975 return SimpleResult.serror([{ 976 path: path, 977 getErrorInfo: getErrorInfo 978 }]); 979 }; 980 var missingStrict = function (path, key, obj) { 981 return nu(path, function () { 982 return 'Could not find valid *strict* value for "' + key + '" in ' + formatObj(obj); 983 }); 984 }; 985 var missingKey = function (path, key) { 986 return nu(path, function () { 987 return 'Choice schema did not contain choice key: "' + key + '"'; 988 }); 989 }; 990 var missingBranch = function (path, branches, branch) { 991 return nu(path, function () { 992 return 'The chosen schema: "' + branch + '" did not exist in branches: ' + formatObj(branches); 993 }); 994 }; 995 var unsupportedFields = function (path, unsupported) { 996 return nu(path, function () { 997 return 'There are unsupported fields: [' + unsupported.join(', ') + '] specified'; 998 }); 999 }; 1000 var custom = function (path, err) { 1001 return nu(path, function () { 1002 return err; 1003 }); 1004 }; 1005 1006 var adt$1 = Adt.generate([ 1007 { 1008 field: [ 1009 'key', 1010 'okey', 1011 'presence', 1012 'prop' 1013 ] 1014 }, 1015 { 1016 state: [ 1017 'okey', 1018 'instantiator' 1019 ] 1020 } 1021 ]); 1022 var strictAccess = function (path, obj, key) { 1023 return get$1(obj, key).fold(function () { 1024 return missingStrict(path, key, obj); 1025 }, SimpleResult.svalue); 1026 }; 1027 var fallbackAccess = function (obj, key, fallbackThunk) { 1028 var v = get$1(obj, key).fold(function () { 1029 return fallbackThunk(obj); 1030 }, identity); 1031 return SimpleResult.svalue(v); 1032 }; 1033 var optionAccess = function (obj, key) { 1034 return SimpleResult.svalue(get$1(obj, key)); 1035 }; 1036 var optionDefaultedAccess = function (obj, key, fallback) { 1037 var opt = get$1(obj, key).map(function (val) { 1038 return val === true ? fallback(obj) : val; 1039 }); 1040 return SimpleResult.svalue(opt); 1041 }; 1042 var cExtractOne = function (path, obj, field, strength) { 1043 return field.fold(function (key, okey, presence, prop) { 1044 var bundle = function (av) { 1045 var result = prop.extract(path.concat([key]), strength, av); 1046 return SimpleResult.map(result, function (res) { 1047 return wrap(okey, strength(res)); 1048 }); 1049 }; 1050 var bundleAsOption = function (optValue) { 1051 return optValue.fold(function () { 1052 var outcome = wrap(okey, strength(Optional.none())); 1053 return SimpleResult.svalue(outcome); 1054 }, function (ov) { 1055 var result = prop.extract(path.concat([key]), strength, ov); 1056 return SimpleResult.map(result, function (res) { 1057 return wrap(okey, strength(Optional.some(res))); 1058 }); 1059 }); 1060 }; 1061 return function () { 1062 return presence.fold(function () { 1063 return SimpleResult.bind(strictAccess(path, obj, key), bundle); 1064 }, function (fallbackThunk) { 1065 return SimpleResult.bind(fallbackAccess(obj, key, fallbackThunk), bundle); 1066 }, function () { 1067 return SimpleResult.bind(optionAccess(obj, key), bundleAsOption); 1068 }, function (fallbackThunk) { 1069 return SimpleResult.bind(optionDefaultedAccess(obj, key, fallbackThunk), bundleAsOption); 1070 }, function (baseThunk) { 1071 var base = baseThunk(obj); 1072 var result = SimpleResult.map(fallbackAccess(obj, key, constant({})), function (v) { 1073 return deepMerge(base, v); 1074 }); 1075 return SimpleResult.bind(result, bundle); 1076 }); 1077 }(); 1078 }, function (okey, instantiator) { 1079 var state = instantiator(obj); 1080 return SimpleResult.svalue(wrap(okey, strength(state))); 1081 }); 1082 }; 1083 var cExtract = function (path, obj, fields, strength) { 1084 var results = map(fields, function (field) { 1085 return cExtractOne(path, obj, field, strength); 1086 }); 1087 return ResultCombine.consolidateObj(results, {}); 1088 }; 1089 var valueThunk = function (getDelegate) { 1090 var extract = function (path, strength, val) { 1091 return getDelegate().extract(path, strength, val); 1092 }; 1093 var toString = function () { 1094 return getDelegate().toString(); 1095 }; 1096 return { 1097 extract: extract, 1098 toString: toString 1099 }; 1100 }; 1101 var value$1 = function (validator) { 1102 var extract = function (path, strength, val) { 1103 return SimpleResult.bindError(validator(val, strength), function (err) { 1104 return custom(path, err); 1105 }); 1106 }; 1107 var toString = function () { 1108 return 'val'; 1109 }; 1110 return { 1111 extract: extract, 1112 toString: toString 1113 }; 1114 }; 1115 var getSetKeys = function (obj) { 1116 return keys(filter$1(obj, function (value) { 1117 return value !== undefined && value !== null; 1118 })); 1119 }; 1120 var objOfOnly = function (fields) { 1121 var delegate = objOf(fields); 1122 var fieldNames = foldr(fields, function (acc, f) { 1123 return f.fold(function (key) { 1124 return deepMerge(acc, wrap$1(key, true)); 1125 }, constant(acc)); 1126 }, {}); 1127 var extract = function (path, strength, o) { 1128 var keys = isBoolean(o) ? [] : getSetKeys(o); 1129 var extra = filter(keys, function (k) { 1130 return !hasNonNullableKey(fieldNames, k); 1131 }); 1132 return extra.length === 0 ? delegate.extract(path, strength, o) : unsupportedFields(path, extra); 1133 }; 1134 return { 1135 extract: extract, 1136 toString: delegate.toString 1137 }; 1138 }; 1139 var objOf = function (fields) { 1140 var extract = function (path, strength, o) { 1141 return cExtract(path, o, fields, strength); 1142 }; 1143 var toString = function () { 1144 var fieldStrings = map(fields, function (field) { 1145 return field.fold(function (key, okey, presence, prop) { 1146 return key + ' -> ' + prop.toString(); 1147 }, function (okey, _instantiator) { 1148 return 'state(' + okey + ')'; 1149 }); 1150 }); 1151 return 'obj{\n' + fieldStrings.join('\n') + '}'; 1152 }; 1153 return { 1154 extract: extract, 1155 toString: toString 1156 }; 1157 }; 1158 var arrOf = function (prop) { 1159 var extract = function (path, strength, array) { 1160 var results = map(array, function (a, i) { 1161 return prop.extract(path.concat(['[' + i + ']']), strength, a); 1162 }); 1163 return ResultCombine.consolidateArr(results); 1164 }; 1165 var toString = function () { 1166 return 'array(' + prop.toString() + ')'; 1167 }; 1168 return { 1169 extract: extract, 1170 toString: toString 1171 }; 1172 }; 1173 var oneOf = function (props) { 1174 var extract = function (path, strength, val) { 1175 var errors = []; 1176 for (var _i = 0, props_1 = props; _i < props_1.length; _i++) { 1177 var prop = props_1[_i]; 1178 var res = prop.extract(path, strength, val); 1179 if (res.stype === SimpleResultType.Value) { 1180 return res; 1181 } 1182 errors.push(res); 1183 } 1184 return ResultCombine.consolidateArr(errors); 1185 }; 1186 var toString = function () { 1187 return 'oneOf(' + map(props, function (prop) { 1188 return prop.toString(); 1189 }).join(', ') + ')'; 1190 }; 1191 return { 1192 extract: extract, 1193 toString: toString 1194 }; 1195 }; 1196 var setOf = function (validator, prop) {
1197 var validateKeys = function (path, keys) { 1198 return arrOf(value$1(validator)).extract(path, identity, keys); 1199 }; 1200 var extract = function (path, strength, o) { 1201 var keys$1 = keys(o); 1202 var validatedKeys = validateKeys(path, keys$1); 1203 return SimpleResult.bind(validatedKeys, function (validKeys) { 1204 var schema = map(validKeys, function (vk) { 1205 return adt$1.field(vk, vk, strict(), prop); 1206 }); 1207 return objOf(schema).extract(path, strength, o); 1208 }); 1209 }; 1210 var toString = function () { 1211 return 'setOf(' + prop.toString() + ')'; 1212 }; 1213 return { 1214 extract: extract, 1215 toString: toString 1216 }; 1217 }; 1218 var thunk = function (desc, processor) { 1219 var getP = cached(function () { 1220 return processor(); 1221 }); 1222 var extract = function (path, strength, val) { 1223 return getP().extract(path, strength, val); 1224 }; 1225 var toString = function () { 1226 return getP().toString(); 1227 }; 1228 return { 1229 extract: extract, 1230 toString: toString 1231 }; 1232 }; 1233 var anyValue = constant(value$1(SimpleResult.svalue)); 1234 var arrOfObj = compose(arrOf, objOf); 1235 var state = adt$1.state; 1236 var field = adt$1.field; 1237 1238 var chooseFrom = function (path, strength, input, branches, ch) { 1239 var fields = get$1(branches, ch); 1240 return fields.fold(function () { 1241 return missingBranch(path, branches, ch); 1242 }, function (vp) { 1243 return vp.extract(path.concat(['branch: ' + ch]), strength, input); 1244 }); 1245 }; 1246 var choose = function (key, branches) { 1247 var extract = function (path, strength, input) {
1248 var choice = get$1(input, key); 1249 return choice.fold(function () { 1250 return missingKey(path, key); 1251 }, function (chosen) { 1252 return chooseFrom(path, strength, input, branches, chosen); 1253 }); 1254 }; 1255 var toString = function () { 1256 return 'chooseOn(' + key + '). Possible values: ' + keys(branches); 1257 }; 1258 return { 1259 extract: extract, 1260 toString: toString 1261 }; 1262 }; 1263 1264 var _anyValue = value$1(SimpleResult.svalue); 1265 var arrOfObj$1 = function (objFields) { 1266 return arrOfObj(objFields); 1267 }; 1268 var arrOfVal = function () { 1269 return arrOf(_anyValue); 1270 }; 1271 var valueThunkOf = valueThunk; 1272 var valueOf = function (validator) { 1273 return value$1(function (v) { 1274 return validator(v).fold(SimpleResult.serror, SimpleResult.svalue); 1275 }); 1276 }; 1277 var setOf$1 = function (validator, prop) { 1278 return setOf(function (v) { 1279 return SimpleResult.fromResult(validator(v)); 1280 }, prop); 1281 }; 1282 var extract = function (label, prop, strength, obj) { 1283 var res = prop.extract([label], strength, obj); 1284 return SimpleResult.mapError(res, function (errs) { 1285 return { 1286 input: obj, 1287 errors: errs 1288 }; 1289 }); 1290 }; 1291 var asRaw = function (label, prop, obj) { 1292 return SimpleResult.toResult(extract(label, prop, identity, obj)); 1293 }; 1294 var getOrDie = function (extraction) { 1295 return extraction.fold(function (errInfo) { 1296 throw new Error(formatError(errInfo)); 1297 }, identity); 1298 }; 1299 var asRawOrDie = function (label, prop, obj) { 1300 return getOrDie(asRaw(label, prop, obj)); 1301 }; 1302 var formatError = function (errInfo) { 1303 return 'Errors: \n' + formatErrors(errInfo.errors).join('\n') + '\n\nInput object: ' + formatObj(errInfo.input); 1304 }; 1305 var chooseProcessor = function (key, branches) { 1306 return choose(key, branches); 1307 }; 1308 var choose$1 = function (key, branches) { 1309 return choose(key, map$2(branches, objOf)); 1310 }; 1311 var thunkOf = function (desc, schema) { 1312 return thunk(desc, schema); 1313 }; 1314 var anyValue$1 = constant(_anyValue); 1315 var typedValue = function (validator, expectedType) { 1316 return value$1(function (a) { 1317 var actualType = typeof a; 1318 return validator(a) ? SimpleResult.svalue(a) : SimpleResult.serror('Expected type: ' + expectedType + ' but got: ' + actualType); 1319 }); 1320 }; 1321 var number = typedValue(isNumber, 'number'); 1322 var string = typedValue(isString, 'string'); 1323 var boolean = typedValue(isBoolean, 'boolean'); 1324 var functionProcessor = typedValue(isFunction, 'function'); 1325 var isPostMessageable = function (val) { 1326 var every = function (iter, callbackFn) { 1327 var result = iter.next(); 1328 while (!result.done) { 1329 if (!callbackFn(result.value)) { 1330 return false; 1331 } 1332 result = iter.next(); 1333 } 1334 return true; 1335 }; 1336 if (Object(val) !== val) { 1337 return true; 1338 } 1339 switch ({}.toString.call(val).slice(8, -1)) { 1340 case 'Boolean': 1341 case 'Number': 1342 case 'String': 1343 case 'Date': 1344 case 'RegExp': 1345 case 'Blob': 1346 case 'FileList': 1347 case 'ImageData': 1348 case 'ImageBitmap': 1349 case 'ArrayBuffer': 1350 return true; 1351 case 'Array': 1352 case 'Object': 1353 return Object.keys(val).every(function (prop) { 1354 return isPostMessageable(val[prop]); 1355 }); 1356 case 'Map': 1357 return every(val.keys(), isPostMessageable) && every(val.values(), isPostMessageable); 1358 case 'Set': 1359 return every(val.keys(), isPostMessageable); 1360 default: 1361 return false; 1362 } 1363 }; 1364 var postMessageable = value$1(function (a) { 1365 return isPostMessageable(a) ? SimpleResult.svalue(a) : SimpleResult.serror('Expected value to be acceptable for sending via postMessage'); 1366 }); 1367 1368 var validateEnum = function (values) { 1369 return valueOf(function (value) { 1370 return contains(values, value) ? Result.value(value) : Result.error('Unsupported value: "' + value + '", choose one of "' + values.join(', ') + '".'); 1371 }); 1372 }; 1373 var strict$1 = function (key) { 1374 return field(key, key, strict(), anyValue()); 1375 }; 1376 var strictOf = function (key, schema) { 1377 return field(key, key, strict(), schema); 1378 }; 1379 var strictNumber = function (key) { 1380 return strictOf(key, number); 1381 }; 1382 var strictString = function (key) { 1383 return strictOf(key, string); 1384 }; 1385 var strictStringEnum = function (key, values) { 1386 return field(key, key, strict(), validateEnum(values)); 1387 }; 1388 var strictBoolean = function (key) { 1389 return strictOf(key, boolean); 1390 }; 1391 var strictFunction = function (key) { 1392 return strictOf(key, functionProcessor); 1393 }; 1394 var forbid = function (key, message) { 1395 return field(key, key, asOption(), value$1(function (_v) { 1396 return SimpleResult.serror('The field: ' + key + ' is forbidden. ' + message); 1397 })); 1398 }; 1399 var strictObjOf = function (key, objSchema) { 1400 return field(key, key, strict(), objOf(objSchema)); 1401 }; 1402 var strictArrayOfObj = function (key, objFields) { 1403 return field(key, key, strict(), arrOfObj(objFields)); 1404 }; 1405 var strictArrayOf = function (key, schema) { 1406 return field(key, key, strict(), arrOf(schema)); 1407 }; 1408 var option = function (key) { 1409 return field(key, key, asOption(), anyValue()); 1410 }; 1411 var optionOf = function (key, schema) { 1412 return field(key, key, asOption(), schema); 1413 }; 1414 var optionNumber = function (key) { 1415 return optionOf(key, number); 1416 }; 1417 var optionString = function (key) { 1418 return optionOf(key, string); 1419 }; 1420 var optionFunction = function (key) { 1421 return optionOf(key, functionProcessor); 1422 }; 1423 var optionArrayOf = function (key, schema) { 1424 return optionOf(key, arrOf(schema)); 1425 }; 1426 var optionObjOf = function (key, objSchema) { 1427 return optionOf(key, objOf(objSchema)); 1428 }; 1429 var optionObjOfOnly = function (key, objSchema) { 1430 return optionOf(key, objOfOnly(objSchema)); 1431 }; 1432 var defaulted$1 = function (key, fallback) { 1433 return field(key, key, defaulted(fallback), anyValue()); 1434 }; 1435 var defaultedOf = function (key, fallback, schema) { 1436 return field(key, key, defaulted(fallback), schema); 1437 }; 1438 var defaultedNumber = function (key, fallback) { 1439 return defaultedOf(key, fallback, number); 1440 }; 1441 var defaultedString = function (key, fallback) { 1442 return defaultedOf(key, fallback, string); 1443 }; 1444 var defaultedStringEnum = function (key, fallback, values) {
1445 return defaultedOf(key, fallback, validateEnum(values)); 1446 }; 1447 var defaultedBoolean = function (key, fallback) { 1448 return defaultedOf(key, fallback, boolean); 1449 }; 1450 var defaultedFunction = function (key, fallback) { 1451 return defaultedOf(key, fallback, functionProcessor); 1452 }; 1453 var defaultedPostMsg = function (key, fallback) { 1454 return defaultedOf(key, fallback, postMessageable); 1455 }; 1456 var defaultedArrayOf = function (key, fallback, schema) { 1457 return defaultedOf(key, fallback, arrOf(schema)); 1458 }; 1459 var defaultedObjOf = function (key, fallback, objSchema) { 1460 return defaultedOf(key, fallback, objOf(objSchema)); 1461 }; 1462 var state$1 = function (okey, instantiator) { 1463 return state(okey, instantiator); 1464 }; 1465 1466 var Cell = function (initial) { 1467 var value = initial; 1468 var get = function () { 1469 return value; 1470 }; 1471 var set = function (v) { 1472 value = v; 1473 }; 1474 return { 1475 get: get, 1476 set: set 1477 }; 1478 }; 1479 1480 var fromHtml = function (html, scope) { 1481 var doc = scope || document; 1482 var div = doc.createElement('div'); 1483 div.innerHTML = html; 1484 if (!div.hasChildNodes() || div.childNodes.length > 1) { 1485 console.error('HTML does not have a single root node', html); 1486 throw new Error('HTML must have a single root node'); 1487 } 1488 return fromDom(div.childNodes[0]); 1489 }; 1490 var fromTag = function (tag, scope) { 1491 var doc = scope || document; 1492 var node = doc.createElement(tag); 1493 return fromDom(node); 1494 }; 1495 var fromText = function (text, scope) { 1496 var doc = scope || document; 1497 var node = doc.createTextNode(text); 1498 return fromDom(node); 1499 }; 1500 var fromDom = function (node) { 1501 if (node === null || node === undefined) { 1502 throw new Error('Node cannot be null or undefined'); 1503 } 1504 return { dom: node }; 1505 }; 1506 var fromPoint = function (docElm, x, y) { 1507 return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom); 1508 }; 1509 var SugarElement = { 1510 fromHtml: fromHtml, 1511 fromTag: fromTag, 1512 fromText: fromText, 1513 fromDom: fromDom, 1514 fromPoint: fromPoint 1515 }; 1516 1517 var DeviceType = function (os, browser, userAgent, mediaMatch) { 1518 var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true; 1519 var isiPhone = os.isiOS() && !isiPad; 1520 var isMobile = os.isiOS() || os.isAndroid(); 1521 var isTouch = isMobile || mediaMatch('(pointer:coarse)'); 1522 var isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)'); 1523 var isPhone = isiPhone || isMobile && !isTablet; 1524 var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false; 1525 var isDesktop = !isPhone && !isTablet && !iOSwebview; 1526 return { 1527 isiPad: constant(isiPad), 1528 isiPhone: constant(isiPhone), 1529 isTablet: constant(isTablet), 1530 isPhone: constant(isPhone), 1531 isTouch: constant(isTouch), 1532 isAndroid: os.isAndroid, 1533 isiOS: os.isiOS, 1534 isWebView: constant(iOSwebview), 1535 isDesktop: constant(isDesktop) 1536 }; 1537 }; 1538 1539 var firstMatch = function (regexes, s) { 1540 for (var i = 0; i < regexes.length; i++) { 1541 var x = regexes[i]; 1542 if (x.test(s)) { 1543 return x; 1544 } 1545 } 1546 return undefined; 1547 }; 1548 var find$2 = function (regexes, agent) { 1549 var r = firstMatch(regexes, agent); 1550 if (!r) { 1551 return { 1552 major: 0, 1553 minor: 0 1554 }; 1555 } 1556 var group = function (i) { 1557 return Number(agent.replace(r, '$' + i)); 1558 }; 1559 return nu$1(group(1), group(2)); 1560 }; 1561 var detect = function (versionRegexes, agent) { 1562 var cleanedAgent = String(agent).toLowerCase(); 1563 if (versionRegexes.length === 0) { 1564 return unknown(); 1565 } 1566 return find$2(versionRegexes, cleanedAgent); 1567 }; 1568 var unknown = function () { 1569 return nu$1(0, 0); 1570 }; 1571 var nu$1 = function (major, minor) { 1572 return { 1573 major: major, 1574 minor: minor 1575 }; 1576 }; 1577 var Version = { 1578 nu: nu$1, 1579 detect: detect, 1580 unknown: unknown 1581 }; 1582 1583 var detect$1 = function (candidates, userAgent) { 1584 var agent = String(userAgent).toLowerCase(); 1585 return find(candidates, function (candidate) { 1586 return candidate.search(agent); 1587 }); 1588 }; 1589 var detectBrowser = function (browsers, userAgent) { 1590 return detect$1(browsers, userAgent).map(function (browser) { 1591 var version = Version.detect(browser.versionRegexes, userAgent); 1592 return { 1593 current: browser.name, 1594 version: version 1595 }; 1596 }); 1597 }; 1598 var detectOs = function (oses, userAgent) { 1599 return detect$1(oses, userAgent).map(function (os) { 1600 var version = Version.detect(os.versionRegexes, userAgent); 1601 return { 1602 current: os.name, 1603 version: version 1604 }; 1605 }); 1606 }; 1607 var UaString = { 1608 detectBrowser: detectBrowser, 1609 detectOs: detectOs 1610 }; 1611 1612 var checkRange = function (str, substr, start) { 1613 return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr; 1614 }; 1615 var contains$1 = function (str, substr) { 1616 return str.indexOf(substr) !== -1; 1617 };
1618 var endsWith = function (str, suffix) { 1619 return checkRange(str, suffix, str.length - suffix.length); 1620 }; 1621 var blank = function (r) { 1622 return function (s) { 1623 return s.replace(r, ''); 1624 }; 1625 }; 1626 var trim = blank(/^\s+|\s+$/g); 1627 1628 var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/; 1629 var checkContains = function (target) { 1630 return function (uastring) { 1631 return contains$1(uastring, target); 1632 }; 1633 }; 1634 var browsers = [ 1635 { 1636 name: 'Edge', 1637 versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/], 1638 search: function (uastring) { 1639 return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit'); 1640 } 1641 }, 1642 { 1643 name: 'Chrome', 1644 versionRegexes: [ 1645 /.*?chrome\/([0-9]+)\.([0-9]+).*/, 1646 normalVersionRegex 1647 ], 1648 search: function (uastring) { 1649 return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe'); 1650 } 1651 }, 1652 { 1653 name: 'IE', 1654 versionRegexes: [ 1655 /.*?msie\ ?([0-9]+)\.([0-9]+).*/, 1656 /.*?rv:([0-9]+)\.([0-9]+).*/ 1657 ], 1658 search: function (uastring) { 1659 return contains$1(uastring, 'msie') || contains$1(uastring, 'trident'); 1660 } 1661 }, 1662 { 1663 name: 'Opera', 1664 versionRegexes: [ 1665 normalVersionRegex, 1666 /.*?opera\/([0-9]+)\.([0-9]+).*/ 1667 ], 1668 search: checkContains('opera') 1669 }, 1670 { 1671 name: 'Firefox', 1672 versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/], 1673 search: checkContains('firefox') 1674 }, 1675 { 1676 name: 'Safari', 1677 versionRegexes: [ 1678 normalVersionRegex, 1679 /.*?cpu os ([0-9]+)_([0-9]+).*/ 1680 ], 1681 search: function (uastring) { 1682 return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit'); 1683 } 1684 } 1685 ]; 1686 var oses = [ 1687 { 1688 name: 'Windows', 1689 search: checkContains('win'), 1690 versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/] 1691 }, 1692 { 1693 name: 'iOS', 1694 search: function (uastring) { 1695 return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad'); 1696 }, 1697 versionRegexes: [ 1698 /.*?version\/\ ?([0-9]+)\.([0-9]+).*/, 1699 /.*cpu os ([0-9]+)_([0-9]+).*/, 1700 /.*cpu iphone os ([0-9]+)_([0-9]+).*/ 1701 ] 1702 }, 1703 { 1704 name: 'Android', 1705 search: checkContains('android'), 1706 versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/] 1707 }, 1708 { 1709 name: 'OSX', 1710 search: checkContains('mac os x'), 1711 versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/] 1712 }, 1713 { 1714 name: 'Linux', 1715 search: checkContains('linux'), 1716 versionRegexes: [] 1717 }, 1718 { 1719 name: 'Solaris', 1720 search: checkContains('sunos'), 1721 versionRegexes: [] 1722 }, 1723 { 1724 name: 'FreeBSD', 1725 search: checkContains('freebsd'), 1726 versionRegexes: [] 1727 }, 1728 { 1729 name: 'ChromeOS', 1730 search: checkContains('cros'), 1731 versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/] 1732 } 1733 ]; 1734 var PlatformInfo = { 1735 browsers: constant(browsers), 1736 oses: constant(oses) 1737 }; 1738 1739 var edge = 'Edge'; 1740 var chrome = 'Chrome'; 1741 var ie = 'IE'; 1742 var opera = 'Opera'; 1743 var firefox = 'Firefox'; 1744 var safari = 'Safari'; 1745 var unknown$1 = function () { 1746 return nu$2({ 1747 current: undefined, 1748 version: Version.unknown() 1749 }); 1750 }; 1751 var nu$2 = function (info) { 1752 var current = info.current; 1753 var version = info.version; 1754 var isBrowser = function (name) { 1755 return function () { 1756 return current === name; 1757 }; 1758 }; 1759 return { 1760 current: current, 1761 version: version, 1762 isEdge: isBrowser(edge), 1763 isChrome: isBrowser(chrome), 1764 isIE: isBrowser(ie), 1765 isOpera: isBrowser(opera), 1766 isFirefox: isBrowser(firefox),
1767 isSafari: isBrowser(safari) 1768 }; 1769 }; 1770 var Browser = { 1771 unknown: unknown$1, 1772 nu: nu$2, 1773 edge: constant(edge), 1774 chrome: constant(chrome), 1775 ie: constant(ie), 1776 opera: constant(opera), 1777 firefox: constant(firefox), 1778 safari: constant(safari) 1779 }; 1780 1781 var windows = 'Windows'; 1782 var ios = 'iOS'; 1783 var android = 'Android'; 1784 var linux = 'Linux'; 1785 var osx = 'OSX'; 1786 var solaris = 'Solaris'; 1787 var freebsd = 'FreeBSD'; 1788 var chromeos = 'ChromeOS'; 1789 var unknown$2 = function () { 1790 return nu$3({ 1791 current: undefined, 1792 version: Version.unknown() 1793 }); 1794 }; 1795 var nu$3 = function (info) { 1796 var current = info.current; 1797 var version = info.version; 1798 var isOS = function (name) { 1799 return function () { 1800 return current === name; 1801 }; 1802 }; 1803 return { 1804 current: current, 1805 version: version, 1806 isWindows: isOS(windows), 1807 isiOS: isOS(ios), 1808 isAndroid: isOS(android), 1809 isOSX: isOS(osx), 1810 isLinux: isOS(linux), 1811 isSolaris: isOS(solaris), 1812 isFreeBSD: isOS(freebsd), 1813 isChromeOS: isOS(chromeos) 1814 }; 1815 }; 1816 var OperatingSystem = { 1817 unknown: unknown$2, 1818 nu: nu$3, 1819 windows: constant(windows), 1820 ios: constant(ios), 1821 android: constant(android), 1822 linux: constant(linux), 1823 osx: constant(osx), 1824 solaris: constant(solaris), 1825 freebsd: constant(freebsd), 1826 chromeos: constant(chromeos) 1827 }; 1828 1829 var detect$2 = function (userAgent, mediaMatch) { 1830 var browsers = PlatformInfo.browsers(); 1831 var oses = PlatformInfo.oses(); 1832 var browser = UaString.detectBrowser(browsers, userAgent).fold(Browser.unknown, Browser.nu); 1833 var os = UaString.detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu); 1834 var deviceType = DeviceType(os, browser, userAgent, mediaMatch); 1835 return { 1836 browser: browser, 1837 os: os, 1838 deviceType: deviceType 1839 }; 1840 }; 1841 var PlatformDetection = { detect: detect$2 }; 1842 1843 var mediaMatch = function (query) { 1844 return window.matchMedia(query).matches; 1845 }; 1846 var platform = cached(function () { 1847 return PlatformDetection.detect(navigator.userAgent, mediaMatch); 1848 }); 1849 var detect$3 = function () { 1850 return platform(); 1851 }; 1852 1853 var compareDocumentPosition = function (a, b, match) { 1854 return (a.compareDocumentPosition(b) & match) !== 0; 1855 }; 1856 var documentPositionContainedBy = function (a, b) { 1857 return compareDocumentPosition(a, b, Node.DOCUMENT_POSITION_CONTAINED_BY); 1858 }; 1859 1860 var DOCUMENT = 9; 1861 var DOCUMENT_FRAGMENT = 11; 1862 var ELEMENT = 1; 1863 var TEXT = 3; 1864 1865 var is = function (element, selector) { 1866 var dom = element.dom; 1867 if (dom.nodeType !== ELEMENT) { 1868 return false; 1869 } else { 1870 var elem = dom; 1871 if (elem.matches !== undefined) { 1872 return elem.matches(selector); 1873 } else if (elem.msMatchesSelector !== undefined) { 1874 return elem.msMatchesSelector(selector); 1875 } else if (elem.webkitMatchesSelector !== undefined) { 1876 return elem.webkitMatchesSelector(selector); 1877 } else if (elem.mozMatchesSelector !== undefined) { 1878 return elem.mozMatchesSelector(selector); 1879 } else { 1880 throw new Error('Browser lacks native selectors'); 1881 } 1882 } 1883 }; 1884 var bypassSelector = function (dom) { 1885 return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT || dom.childElementCount === 0; 1886 }; 1887 var all = function (selector, scope) { 1888 var base = scope === undefined ? document : scope.dom; 1889 return bypassSelector(base) ? [] : map(base.querySelectorAll(selector), SugarElement.fromDom); 1890 }; 1891 var one = function (selector, scope) { 1892 var base = scope === undefined ? document : scope.dom; 1893 return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom); 1894 }; 1895 1896 var eq$1 = function (e1, e2) { 1897 return e1.dom === e2.dom; 1898 }; 1899 var regularContains = function (e1, e2) { 1900 var d1 = e1.dom; 1901 var d2 = e2.dom; 1902 return d1 === d2 ? false : d1.contains(d2); 1903 }; 1904 var ieContains = function (e1, e2) { 1905 return documentPositionContainedBy(e1.dom, e2.dom); 1906 }; 1907 var contains$2 = function (e1, e2) { 1908 return detect$3().browser.isIE() ? ieContains(e1, e2) : regularContains(e1, e2); 1909 }; 1910 1911 var ensureIsRoot = function (isRoot) { 1912 return isFunction(isRoot) ? isRoot : never; 1913 }; 1914 var ancestor = function (scope, transform, isRoot) { 1915 var element = scope.dom; 1916 var stop = ensureIsRoot(isRoot); 1917 while (element.parentNode) { 1918 element = element.parentNode; 1919 var el = SugarElement.fromDom(element); 1920 var transformed = transform(el); 1921 if (transformed.isSome()) { 1922 return transformed; 1923 } else if (stop(el)) { 1924 break; 1925 } 1926 } 1927 return Optional.none(); 1928 }; 1929 var closest = function (scope, transform, isRoot) { 1930 var current = transform(scope); 1931 var stop = ensureIsRoot(isRoot); 1932 return current.orThunk(function () { 1933 return stop(scope) ? Optional.none() : ancestor(scope, transform, stop
1933); 1934 }); 1935 }; 1936 1937 var isSource = function (component, simulatedEvent) { 1938 return eq$1(component.element, simulatedEvent.event.target); 1939 }; 1940 1941 var nu$4 = function (parts) { 1942 if (!hasNonNullableKey(parts, 'can') && !hasNonNullableKey(parts, 'abort') && !hasNonNullableKey(parts, 'run')) { 1943 throw new Error('EventHandler defined by: ' + JSON.stringify(parts, null, 2) + ' does not have can, abort, or run!'); 1944 } 1945 return asRawOrDie('Extracting event.handler', objOfOnly([ 1946 defaulted$1('can', always), 1947 defaulted$1('abort', never), 1948 defaulted$1('run', noop) 1949 ]), parts); 1950 }; 1951 var all$1 = function (handlers, f) { 1952 return function () { 1953 var args = []; 1954 for (var _i = 0; _i < arguments.length; _i++) { 1955 args[_i] = arguments[_i]; 1956 } 1957 return foldl(handlers, function (acc, handler) { 1958 return acc && f(handler).apply(undefined, args); 1959 }, true); 1960 }; 1961 }; 1962 var any = function (handlers, f) { 1963 return function () { 1964 var args = []; 1965 for (var _i = 0; _i < arguments.length; _i++) { 1966 args[_i] = arguments[_i]; 1967 } 1968 return foldl(handlers, function (acc, handler) { 1969 return acc || f(handler).apply(undefined, args); 1970 }, false); 1971 }; 1972 }; 1973 var read = function (handler) { 1974 return isFunction(handler) ? { 1975 can: always, 1976 abort: never, 1977 run: handler 1978 } : handler; 1979 }; 1980 var fuse = function (handlers) { 1981 var can = all$1(handlers, function (handler) { 1982 return handler.can; 1983 }); 1984 var abort = any(handlers, function (handler) { 1985 return handler.abort; 1986 }); 1987 var run = function () { 1988 var args = []; 1989 for (var _i = 0; _i < arguments.length; _i++) { 1990 args[_i] = arguments[_i]; 1991 } 1992 each(handlers, function (handler) { 1993 handler.run.apply(undefined, args); 1994 }); 1995 }; 1996 return nu$4({ 1997 can: can, 1998 abort: abort, 1999 run: run 2000 }); 2001 }; 2002 2003 var constant$1 = constant; 2004 var touchstart = constant$1('touchstart'); 2005 var touchmove = constant$1('touchmove'); 2006 var touchend = constant$1('touchend'); 2007 var touchcancel = constant$1('touchcancel'); 2008 var mousedown = constant$1('mousedown'); 2009 var mousemove = constant$1('mousemove'); 2010 var mouseout = constant$1('mouseout'); 2011 var mouseup = constant$1('mouseup'); 2012 var mouseover = constant$1('mouseover'); 2013 var focusin = constant$1('focusin'); 2014 var focusout = constant$1('focusout'); 2015 var keydown = constant$1('keydown'); 2016 var keyup = constant$1('keyup'); 2017 var input = constant$1('input'); 2018 var change = constant$1('change'); 2019 var click = constant$1('click'); 2020 var transitionend = constant$1('transitionend'); 2021 var selectstart = constant$1('selectstart'); 2022 2023 var prefixName = function (name) { 2024 return constant('alloy.' + name); 2025 }; 2026 var alloy = { tap: prefixName('tap') }; 2027 var focus = prefixName('focus'); 2028 var postBlur = prefixName('blur.post'); 2029 var postPaste = prefixName('paste.post'); 2030 var receive = prefixName('receive'); 2031 var execute = prefixName('execute'); 2032 var focusItem = prefixName('focus.item'); 2033 var tap = alloy.tap; 2034 var longpress = prefixName('longpress'); 2035 var sandboxClose = prefixName('sandbox.close'); 2036 var typeaheadCancel = prefixName('typeahead.cancel'); 2037 var systemInit = prefixName('system.init'); 2038 var documentTouchmove = prefixName('system.touchmove'); 2039 var documentTouchend = prefixName('system.touchend'); 2040 var windowScroll = prefixName('system.scroll'); 2041 var windowResize = prefixName('system.resize'); 2042 var attachedToDom = prefixName('system.attached'); 2043 var detachedFromDom = prefixName('system.detached'); 2044 var dismissRequested = prefixName('system.dismissRequested'); 2045 var repositionRequested = prefixName('system.repositionRequested'); 2046 var focusShifted = prefixName('focusmanager.shifted'); 2047 var slotVisibility = prefixName('slotcontainer.visibility'); 2048 var changeTab = prefixName('change.tab'); 2049 var dismissTab = prefixName('dismiss.tab'); 2050 var highlight = prefixName('highlight'); 2051 var dehighlight = prefixName('dehighlight'); 2052 2053 var emit = function (component, event) { 2054 dispatchWith(component, component.element, event, {}); 2055 }; 2056 var emitWith = function (component, event, properties) { 2057 dispatchWith(component, component.element, event, properties); 2058 }; 2059 var emitExecute = function (component) { 2060 emit(component, execute()); 2061 }; 2062 var dispatch = function (component, target, event) { 2063 dispatchWith(component, target, event, {}); 2064 }; 2065 var dispatchWith = function (component, target, event, properties) { 2066 var data = __assign({ target: target }, properties); 2067 component.getSystem().triggerEvent(event, target, data); 2068 }; 2069 var dispatchEvent = function (component, target, event, simulatedEvent) { 2070 component.getSystem().triggerEvent(event, target, simulatedEvent.event); 2071 }; 2072 2073 var derive = function (configs) { 2074 return wrapAll$1(configs); 2075 }; 2076 var abort = function (name, predicate) { 2077 return { 2078 key: name, 2079 value: nu$4({ abort: predicate }) 2080 }; 2081 }; 2082 var can = function (name, predicate) { 2083 return { 2084 key: name, 2085 value: nu$4({ can: predicate }) 2086 }; 2087 }; 2088 var preventDefault = function (name) { 2089 return { 2090 key: name, 2091 value: nu$4({ 2092 run: function (component, simulatedEvent) { 2093 simulatedEvent.event.prevent(); 2094 } 2095 }) 2096 }; 2097 }; 2098 var run = function (name, handler) { 2099 return { 2100 key: name, 2101 value: nu$4({ run: handler }) 2102 }; 2103 }; 2104 var runActionExtra = function (name, action, extra) { 2105 return { 2106 key: name, 2107 value: nu$4({ 2108 run: function (component, simulatedEvent) { 2109 action.apply(undefined, [ 2110 component, 2111 simulatedEvent 2112 ].concat(extra)); 2113 } 2114 }) 2115 }; 2116 }; 2117 var runOnName = function (name) { 2118 return function (handler) { 2119 return run(name, handler); 2120 }; 2121 }; 2122 var runOnSourceName = function (name) { 2123 return function (handler) { 2124 return { 2125 key: name, 2126 value: nu$4({ 2127 run: function (component, simulatedEvent) { 2128 if (isSource(component, simulatedEvent)) { 2129 handler(component, simulatedEvent); 2130 } 2131 } 2132 }) 2133 }; 2134 }; 2135 }; 2136 var redirectToUid = function (name, uid) { 2137 return run(name, function (component, simulatedEvent) { 2138 component.getSystem().getByUid(uid).each(function (redirectee) { 2139 dispatchEvent(redirectee, redirectee.element, name, simulatedEvent); 2140 }); 2141 }); 2142 }; 2143 var redirectToPart = function (name, detail, partName) { 2144 var uid = detail.partUids[partName]; 2145 return redirectToUid(name, uid); 2146 }; 2147 var runWithTarget = function (name, f) { 2148 return run(name, function (component, simulatedEvent) { 2149 var ev = simulatedEvent.event; 2150 var target = component.getSystem().getByDom(ev.target).fold(function () { 2151 var closest$1 = closest(ev.target, function (el) { 2152 return component.getSystem().getByDom(el).toOptional(); 2153 }, never); 2154 return closest$1.getOr(component); 2155 }, function (c) { 2156 return c; 2157 }); 2158 f(component, target, simulatedEvent); 2159 }); 2160 }; 2161 var cutter = function (name) { 2162 return run(name, function (component, simulatedEvent) { 2163 simulatedEvent.cut(); 2164 }); 2165 }; 2166 var stopper = function (name) { 2167 return run(name, function (component, simulatedEvent) { 2168 simulatedEvent.stop(); 2169 }); 2170 }; 2171 var runOnSource = function (name, f) { 2172 return runOnSourceName(name)(f); 2173 }; 2174 var runOnAttached = runOnSourceName(attachedToDom()); 2175 var runOnDetached = runOnSourceName(detachedFromDom()); 2176 var runOnInit = runOnSourceName(systemInit()); 2177 var runOnExecute = runOnName(execute()); 2178 2179 var Global = typeof window !== 'undefined' ? window : Function('return this;')(); 2180 2181 var name = function (element) { 2182 var r = element.dom.nodeName; 2183 return r.toLowerCase(); 2184 }; 2185 var type = function (element) { 2186 return element.dom.nodeType; 2187 }; 2188 var isType$1 = function (t) { 2189 return function (element) { 2190 return type(element) === t; 2191 }; 2192 }; 2193 var isElement = isType$1(ELEMENT); 2194 var isText = isType$1(TEXT); 2195 var isDocument = isType$1(DOCUMENT); 2196 var isDocumentFragment = isType$1(DOCUMENT_FRAGMENT); 2197 2198 var owner = function (element) { 2199 return SugarElement.fromDom(element.dom.ownerDocument); 2200 }; 2201 var documentOrOwner = function (dos) { 2202 return isDocument(dos) ? dos : owner(dos); 2203 }; 2204 var documentElement = function (element) { 2205 return SugarElement.fromDom(documentOrOwner(element).dom.documentElement); 2206 }; 2207 var defaultView = function (element) { 2208 return SugarElement.fromDom(documentOrOwner(element).dom.defaultView); 2209 }; 2210 var parent = function (element) { 2211 return Optional.from(element.dom.parentNode).map(SugarElement.fromDom); 2212 }; 2213 var parentNode = function (element) { 2214 return parent(element); 2215 }; 2216 var offsetParent = function (element) { 2217 return Optional.from(element.dom.offsetParent).map(SugarElement.fromDom); 2218 }; 2219 var nextSibling = function (element) { 2220 return Optional.from(element.dom.nextSibling).map(SugarElement.fromDom); 2221 }; 2222 var children = function (element) { 2223 return map(element.dom.childNodes, SugarElement.fromDom); 2224 }; 2225 var child = function (element, index) { 2226 var cs = element.dom.childNodes; 2227 return Optional.from(cs[index]).map(SugarElement.fromDom); 2228 }; 2229 var firstChild = function (element) { 2230 return child(element, 0); 2231 }; 2232 2233 var isShadowRoot = function (dos) { 2234 return isDocumentFragment(dos) && isNonNullable(dos.dom.host); 2235 }; 2236 var supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode); 2237 var isSupported = constant(supported); 2238 var getRootNode = supported ? function (e) { 2239 return SugarElement.fromDom(e.dom.getRootNode()); 2240 } : documentOrOwner; 2241 var getContentContainer = function (dos) { 2242 return isShadowRoot(dos) ? dos : SugarElement.fromDom(documentOrOwner(dos).dom.body); 2243 }; 2244 var isInShadowRoot = function (e) { 2245 return getShadowRoot(e).isSome(); 2246 }; 2247 var getShadowRoot = function (e) { 2248 var r = getRootNode(e); 2249 return isShadowRoot(r) ? Optional.some(r) : Optional.none(); 2250 }; 2251 var getShadowHost = function (e) { 2252 return SugarElement.fromDom(e.dom.host); 2253 }; 2254 var getOriginalEventTarget = function (event) { 2255 if (isSupported() && isNonNullable(event.target)) { 2256 var el = SugarElement.fromDom(event.target); 2257 if (isElement(el) && isOpenShadowHost(el)) { 2258 if (event.composed && event.composedPath) { 2259 var composedPath = event.composedPath(); 2260 if (composedPath) { 2261 return head(composedPath); 2262 } 2263 } 2264 } 2265 } 2266 return Optional.from(event.target); 2267 }; 2268 var isOpenShadowHost = function (element) { 2269 return isNonNullable(element.dom.shadowRoot); 2270 }; 2271 2272 var before = function (marker, element) { 2273 var parent$1 = parent(marker); 2274 parent$1.each(function (v) { 2275 v.dom.insertBefore(element.dom, marker.dom); 2276 }); 2277 }; 2278 var after = function (marker, element) { 2279 var sibling = nextSibling(marker); 2280 sibling.fold(function () { 2281 var parent$1 = parent(marker); 2282 parent$1.each(function (v) { 2283 append(v, element); 2284 }); 2285 }, function (v) { 2286 before(v, element); 2287 }); 2288 }; 2289 var prepend = function (parent, element) { 2290 var firstChild$1 = firstChild(parent); 2291 firstChild$1.fold(function () { 2292 append(parent, element); 2293 }, function (v) { 2294 parent.dom.insertBefore(element.dom, v.dom); 2295 }); 2296 }; 2297 var append = function (parent, element) { 2298 parent.dom.appendChild(element.dom); 2299 }; 2300 var appendAt = function (parent, element, index) { 2301 child(parent, index).fold(function () { 2302 append(parent, element); 2303 }, function (v) { 2304 before(v, element); 2305 }); 2306 }; 2307 2308 var before$1 = function (marker, elements) { 2309 each(elements, function (x) { 2310 before(marker, x); 2311 }); 2312 }; 2313 var append$1 = function (parent, elements) { 2314 each(elements, function (x) { 2315 append(parent, x); 2316 }); 2317 }; 2318 2319 var empty = function (element) { 2320 element.dom.textContent = ''; 2321 each(children(element), function (rogue) { 2322 remove(rogue); 2323 }); 2324 }; 2325 var remove = function (element) { 2326 var dom = element.dom; 2327 if (dom.parentNode !== null) { 2328 dom.parentNode.removeChild(dom); 2329 } 2330 }; 2331 var unwrap = function (wrapper) { 2332 var children$1 = children(wrapper); 2333 if (children$1.length > 0) { 2334 before$1(wrapper, children$1); 2335 } 2336 remove(wrapper); 2337 }; 2338 2339 var fromHtml$1 = function (html, scope) { 2340 var doc = scope || document; 2341 var div = doc.createElement('div'); 2342 div.innerHTML = html; 2343 return children(SugarElement.fromDom(div)); 2344 }; 2345 2346 var get$2 = function (element) { 2347 return element.dom.innerHTML; 2348 }; 2349 var set = function (element, content) { 2350 var owner$1 = owner(element); 2351 var docDom = owner$1.dom; 2352 var fragment = SugarElement.fromDom(docDom.createDocumentFragment()); 2353 var contentElements = fromHtml$1(content, docDom); 2354 append$1(fragment, contentElements); 2355 empty(element); 2356 append(element, fragment); 2357 }; 2358 var getOuter = function (element) { 2359 var container = SugarElement.fromTag('div'); 2360 var clone = SugarElement.fromDom(element.dom.cloneNode(true)); 2361 append(container, clone); 2362 return get$2(container); 2363 }; 2364 2365 var rawSet = function (dom, key, value) { 2366 if (isString(value) || isBoolean(value) || isNumber(value)) { 2367 dom.setAttribute(key, value + ''); 2368 } else { 2369 console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom); 2370 throw new Error('Attribute value was not simple'); 2371 } 2372 }; 2373 var set$1 = function (element, key, value) { 2374 rawSet(element.dom, key, value); 2375 }; 2376 var setAll = function (element, attrs) { 2377 var dom = element.dom; 2378 each$1(attrs, function (v, k) { 2379 rawSet(dom, k, v); 2380 }); 2381 }; 2382 var get$3 = function (element, key) { 2383 var v = element.dom.getAttribute(key); 2384 return v === null ? undefined : v; 2385 }; 2386 var getOpt = function (element, key) { 2387 return Optional.from(get$3(element, key)); 2388 }; 2389 var has$1 = function (element, key) { 2390 var dom = element.dom; 2391 return dom && dom.hasAttribute ? dom.hasAttribute(key) : false;
2392 }; 2393 var remove$1 = function (element, key) { 2394 element.dom.removeAttribute(key); 2395 }; 2396 2397 var clone = function (original, isDeep) { 2398 return SugarElement.fromDom(original.dom.cloneNode(isDeep)); 2399 }; 2400 var shallow$1 = function (original) { 2401 return clone(original, false); 2402 }; 2403 2404 var getHtml = function (element) { 2405 if (isShadowRoot(element)) { 2406 return '#shadow-root'; 2407 } else { 2408 var clone = shallow$1(element); 2409 return getOuter(clone); 2410 } 2411 }; 2412 2413 var element = function (elem) { 2414 return getHtml(elem); 2415 }; 2416 2417 var isRecursive = function (component, originator, target) { 2418 return eq$1(originator, component.element) && !eq$1(originator, target); 2419 }; 2420 var events = derive([can(focus(), function (component, simulatedEvent) { 2421 var event = simulatedEvent.event; 2422 var originator = event.originator; 2423 var target = event.target; 2424 if (isRecursive(component, originator, target)) { 2425 console.warn(focus() + ' did not get interpreted by the desired target. ' + '\nOriginator: ' + element(originator) + '\nTarget: ' + element(target) + '\nCheck the ' + focus() + ' event handlers'); 2426 return false; 2427 } else { 2428 return true; 2429 } 2430 })]); 2431 2432 var DefaultEvents = /*#__PURE__*/Object.freeze({ 2433 __proto__: null, 2434 events: events 2435 }); 2436 2437 var unique = 0; 2438 var generate$1 = function (prefix) { 2439 var date = new Date(); 2440 var time = date.getTime(); 2441 var random = Math.floor(Math.random() * 1000000000); 2442 unique++; 2443 return prefix + '_' + random + unique + String(time); 2444 }; 2445 2446 var prefix = constant('alloy-id-'); 2447 var idAttr = constant('data-alloy-id'); 2448 2449 var prefix$1 = prefix(); 2450 var idAttr$1 = idAttr(); 2451 var write = function (label, elem) { 2452 var id = generate$1(prefix$1 + label); 2453 writeOnly(elem, id); 2454 return id; 2455 }; 2456 var writeOnly = function (elem, uid) { 2457 Object.defineProperty(elem.dom, idAttr$1, { 2458 value: uid, 2459 writable: true 2460 }); 2461 }; 2462 var read$1 = function (elem) { 2463 var id = isElement(elem) ? elem.dom[idAttr$1] : null; 2464 return Optional.from(id); 2465 }; 2466 var generate$2 = function (prefix) { 2467 return generate$1(prefix); 2468 }; 2469 2470 var make = identity; 2471 2472 var NoContextApi = function (getComp) { 2473 var fail = function (event) { 2474 return function () { 2475 throw new Error('The component must be in a context to send: ' + event + (getComp ? '\n' + element(getComp().element) + ' is not in context.' : '')); 2476 }; 2477 }; 2478 return { 2479 debugInfo: constant('fake'), 2480 triggerEvent: fail('triggerEvent'), 2481 triggerFocus: fail('triggerFocus'), 2482 triggerEscape: fail('triggerEscape'), 2483 build: fail('build'), 2484 addToWorld: fail('addToWorld'), 2485 removeFromWorld: fail('removeFromWorld'), 2486 addToGui: fail('addToGui'), 2487 removeFromGui: fail('removeFromGui'), 2488 getByUid: fail('getByUid'), 2489 getByDom: fail('getByDom'), 2490 broadcast: fail('broadcast'), 2491 broadcastOn: fail('broadcastOn'), 2492 broadcastEvent: fail('broadcastEvent'), 2493 isConnected: never 2494 }; 2495 }; 2496 var singleton = NoContextApi(); 2497 2498 var markAsBehaviourApi = function (f, apiName, apiFunction) { 2499 var delegate = apiFunction.toString(); 2500 var endIndex = delegate.indexOf(')') + 1; 2501 var openBracketIndex = delegate.indexOf('('); 2502 var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/); 2503 f.toFunctionAnnotation = function () { 2504 return { 2505 name: apiName, 2506 parameters: cleanParameters(parameters.slice(0, 1).concat(parameters.slice(3))) 2507 }; 2508 }; 2509 return f; 2510 }; 2511 var cleanParameters = function (parameters) { 2512 return map(parameters, function (p) { 2513 return endsWith(p, '/*') ? p.substring(0, p.length - '/*'.length) : p; 2514 }); 2515 }; 2516 var markAsExtraApi = function (f, extraName) { 2517 var delegate = f.toString(); 2518 var endIndex = delegate.indexOf(')') + 1; 2519 var openBracketIndex = delegate.indexOf('('); 2520 var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/); 2521 f.toFunctionAnnotation = function () { 2522 return { 2523 name: extraName, 2524 parameters: cleanParameters(parameters) 2525 }; 2526 }; 2527 return f; 2528 }; 2529 var markAsSketchApi = function (f, apiFunction) { 2530 var delegate = apiFunction.toString(); 2531 var endIndex = delegate.indexOf(')') + 1; 2532 var openBracketIndex = delegate.indexOf('('); 2533 var parameters = delegate.substring(openBracketIndex + 1, endIndex - 1).split(/,\s*/); 2534 f.toFunctionAnnotation = function () { 2535 return { 2536 name: 'OVERRIDE', 2537 parameters: cleanParameters(parameters.slice(1)) 2538 }; 2539 }; 2540 return f; 2541 }; 2542 2543 var premadeTag = generate$1('alloy-premade'); 2544 var premade = function (comp) { 2545 return wrap$1(premadeTag, comp); 2546 }; 2547 var getPremade = function (spec) { 2548 return get$1(spec, premadeTag); 2549 }; 2550 var makeApi = function (f) { 2551 return markAsSketchApi(function (component) { 2552 var rest = []; 2553 for (var _i = 1; _i < arguments.length; _i++) { 2554 rest[_i - 1] = arguments[_i]; 2555 } 2556 return f.apply(void 0, __spreadArrays([ 2557 component.getApis(), 2558 component 2559 ], rest)); 2560 }, f); 2561 }; 2562 2563 var NoState = { 2564 init: function () { 2565 return nu$5({ 2566 readState: function () { 2567 return 'No State required'; 2568 } 2569 }); 2570 } 2571 }; 2572 var nu$5 = function (spec) { 2573 return spec; 2574 }; 2575 2576 var generateFrom = function (spec, all) { 2577 var schema = map(all, function (a) { 2578 return optionObjOf(a.name(), [
2579 strict$1('config'), 2580 defaulted$1('state', NoState) 2581 ]); 2582 }); 2583 var validated = asRaw('component.behaviours', objOf(schema), spec.behaviours).fold(function (errInfo) { 2584 throw new Error(formatError(errInfo) + '\nComplete spec:\n' + JSON.stringify(spec, null, 2)); 2585 }, function (v) { 2586 return v; 2587 }); 2588 return { 2589 list: all, 2590 data: map$2(validated, function (optBlobThunk) { 2591 var output = optBlobThunk.map(function (blob) { 2592 return { 2593 config: blob.config, 2594 state: blob.state.init(blob.config) 2595 }; 2596 }); 2597 return function () { 2598 return output; 2599 }; 2600 }) 2601 }; 2602 }; 2603 var getBehaviours = function (bData) { 2604 return bData.list; 2605 }; 2606 var getData = function (bData) { 2607 return bData.data; 2608 }; 2609 2610 var byInnerKey = function (data, tuple) { 2611 var r = {}; 2612 each$1(data, function (detail, key) { 2613 each$1(detail, function (value, indexKey) { 2614 var chain = get$1(r, indexKey).getOr([]); 2615 r[indexKey] = chain.concat([tuple(key, value)]); 2616 }); 2617 }); 2618 return r; 2619 }; 2620 2621 var nu$6 = function (s) { 2622 return { 2623 classes: s.classes !== undefined ? s.classes : [], 2624 attributes: s.attributes !== undefined ? s.attributes : {}, 2625 styles: s.styles !== undefined ? s.styles : {} 2626 }; 2627 }; 2628 var merge$1 = function (defnA, mod) { 2629 return __assign(__assign({}, defnA), { 2630 attributes: __assign(__assign({}, defnA.attributes), mod.attributes), 2631 styles: __assign(__assign({}, defnA.styles), mod.styles), 2632 classes: defnA.classes.concat(mod.classes) 2633 }); 2634 }; 2635 2636 var combine = function (info, baseMod, behaviours, base) { 2637 var modsByBehaviour = __assign({}, baseMod); 2638 each(behaviours, function (behaviour) { 2639 modsByBehaviour[behaviour.name()] = behaviour.exhibit(info, base); 2640 }); 2641 var byAspect = byInnerKey(modsByBehaviour, function (name, modification) { 2642 return { 2643 name: name, 2644 modification: modification 2645 }; 2646 }); 2647 var combineObjects = function (objects) { 2648 return foldr(objects, function (b, a) { 2649 return __assign(__assign({}, a.modification), b); 2650 }, {}); 2651 }; 2652 var combinedClasses = foldr(byAspect.classes, function (b, a) { 2653 return a.modification.concat(b); 2654 }, []); 2655 var combinedAttributes = combineObjects(byAspect.attributes); 2656 var combinedStyles = combineObjects(byAspect.styles); 2657 return nu$6({ 2658 classes: combinedClasses, 2659 attributes: combinedAttributes, 2660 styles: combinedStyles 2661 }); 2662 }; 2663 2664 var sortKeys = function (label, keyName, array, order) { 2665 try { 2666 var sorted = sort(array, function (a, b) { 2667 var aKey = a[keyName]; 2668 var bKey = b[keyName]; 2669 var aIndex = order.indexOf(aKey); 2670 var bIndex = order.indexOf(bKey); 2671 if (aIndex === -1) { 2672 throw new Error('The ordering for ' + label + ' does not have an entry for ' + aKey + '.\nOrder specified: ' + JSON.stringify(order, null, 2)); 2673 } 2674 if (bIndex === -1) { 2675 throw new Error('The ordering for ' + label + ' does not have an entry for ' + bKey + '.\nOrder specified: ' + JSON.stringify(order, null, 2)); 2676 } 2677 if (aIndex < bIndex) { 2678 return -1; 2679 } else if (bIndex < aIndex) { 2680 return 1; 2681 } else { 2682 return 0; 2683 } 2684 }); 2685 return Result.value(sorted); 2686 } catch (err) { 2687 return Result.error([err]); 2688 } 2689 }; 2690 2691 var uncurried = function (handler, purpose) { 2692 return { 2693 handler: handler, 2694 purpose: purpose 2695 }; 2696 }; 2697 var curried = function (handler, purpose) { 2698 return { 2699 cHandler: handler, 2700 purpose: purpose 2701 }; 2702 }; 2703 var curryArgs = function (descHandler, extraArgs) { 2704 return curried(curry.apply(undefined, [descHandler.handler].concat(extraArgs)), descHandler.purpose); 2705 }; 2706 var getCurried = function (descHandler) { 2707 return descHandler.cHandler; 2708 }; 2709 2710 var behaviourTuple = function (name, handler) { 2711 return { 2712 name: name, 2713 handler: handler 2714 }; 2715 }; 2716 var nameToHandlers = function (behaviours, info) { 2717 var r = {}; 2718 each(behaviours, function (behaviour) { 2719 r[behaviour.name()] = behaviour.handlers(info); 2720 }); 2721 return r; 2722 }; 2723 var groupByEvents = function (info, behaviours, base) { 2724 var behaviourEvents = __assign(__assign({}, base), nameToHandlers(behaviours, info)); 2725 return byInnerKey(behaviourEvents, behaviourTuple); 2726 }; 2727 var combine$1 = function (info, eventOrder, behaviours, base) { 2728 var byEventName = groupByEvents(info, behaviours, base); 2729 return combineGroups(byEventName, eventOrder); 2730 }; 2731 var assemble = function (rawHandler) { 2732 var handler = read(rawHandler); 2733 return function (component, simulatedEvent) { 2734 var rest = []; 2735 for (var _i = 2; _i < arguments.length; _i++) { 2736 rest[_i - 2] = arguments[_i]; 2737 } 2738 var args = [ 2739 component, 2740 simulatedEvent 2741 ].concat(rest); 2742 if (handler.abort.apply(undefined, args)) { 2743 simulatedEvent.stop(); 2744 } else if (handler.can.apply(undefined, args)) { 2745 handler.run.apply(undefined, args); 2746 } 2747 }; 2748 }; 2749 var missingOrderError = function (eventName, tuples) { 2750 return Result.error(['The event (' + eventName + ') has more than one behaviour that listens to it.\nWhen this occurs, you must ' + 'specify an event ordering for the behaviours in your spec (e.g. [ "listing", "toggling" ]).\nThe behaviours that ' + 'can trigger it are: ' + JSON.stringify(ma
2750p(tuples, function (c) { 2751 return c.name; 2752 }), null, 2)]); 2753 }; 2754 var fuse$1 = function (tuples, eventOrder, eventName) { 2755 var order = eventOrder[eventName]; 2756 if (!order) { 2757 return missingOrderError(eventName, tuples); 2758 } else { 2759 return sortKeys('Event: ' + eventName, 'name', tuples, order).map(function (sortedTuples) { 2760 var handlers = map(sortedTuples, function (tuple) { 2761 return tuple.handler; 2762 }); 2763 return fuse(handlers); 2764 }); 2765 } 2766 }; 2767 var combineGroups = function (byEventName, eventOrder) { 2768 var r = mapToArray(byEventName, function (tuples, eventName) { 2769 var combined = tuples.length === 1 ? Result.value(tuples[0].handler) : fuse$1(tuples, eventOrder, eventName); 2770 return combined.map(function (handler) { 2771 var assembled = assemble(handler); 2772 var purpose = tuples.length > 1 ? filter(eventOrder[eventName], function (o) { 2773 return exists(tuples, function (t) { 2774 return t.name === o; 2775 }); 2776 }).join(' > ') : tuples[0].name; 2777 return wrap$1(eventName, uncurried(assembled, purpose)); 2778 }); 2779 }); 2780 return consolidate(r, {}); 2781 }; 2782 2783 var baseBehaviour = 'alloy.base.behaviour'; 2784 var toInfo = function (spec) { 2785 var _a; 2786 return asRaw('custom.definition', objOf([ 2787 field('dom', 'dom', strict(), objOf([ 2788 strict$1('tag'), 2789 defaulted$1('styles', {}), 2790 defaulted$1('classes', []), 2791 defaulted$1('attributes', {}), 2792 option('value'), 2793 option('innerHtml') 2794 ])), 2795 strict$1('components'), 2796 strict$1('uid'), 2797 defaulted$1('events', {}), 2798 defaulted$1('apis', {}), 2799 field('eventOrder', 'eventOrder', mergeWith((_a = {}, _a[execute()] = [ 2800 'disabling', 2801 baseBehaviour, 2802 'toggling', 2803 'typeaheadevents' 2804 ], _a[focus()] = [ 2805 baseBehaviour, 2806 'focusing', 2807 'keying' 2808 ], _a[systemInit()] = [ 2809 baseBehaviour, 2810 'disabling', 2811 'toggling', 2812 'representing' 2813 ], _a[input()] = [ 2814 baseBehaviour, 2815 'representing', 2816 'streaming', 2817 'invalidating' 2818 ], _a[detachedFromDom()] = [ 2819 baseBehaviour, 2820 'representing', 2821 'item-events', 2822 'tooltipping' 2823 ], _a[mousedown()] = [ 2824 'focusing', 2825 baseBehaviour, 2826 'item-type-events' 2827 ], _a[touchstart()] = [ 2828 'focusing', 2829 baseBehaviour, 2830 'item-type-events' 2831 ], _a[mouseover()] = [ 2832 'item-type-events', 2833 'tooltipping' 2834 ], _a[receive()] = [ 2835 'receiving', 2836 'reflecting', 2837 'tooltipping' 2838 ], _a)), anyValue$1()), 2839 option('domModification') 2840 ]), spec); 2841 }; 2842 var toDefinition = function (detail) { 2843 return __assign(__assign({}, detail.dom), {
2844 uid: detail.uid, 2845 domChildren: map(detail.components, function (comp) { 2846 return comp.element; 2847 }) 2848 }); 2849 }; 2850 var toModification = function (detail) { 2851 return detail.domModification.fold(function () { 2852 return nu$6({}); 2853 }, nu$6); 2854 }; 2855 var toEvents = function (info) { 2856 return info.events; 2857 }; 2858 2859 var read$2 = function (element, attr) { 2860 var value = get$3(element, attr); 2861 return value === undefined || value === '' ? [] : value.split(' '); 2862 }; 2863 var add = function (element, attr, id) { 2864 var old = read$2(element, attr); 2865 var nu = old.concat([id]); 2866 set$1(element, attr, nu.join(' ')); 2867 return true; 2868 }; 2869 var remove$2 = function (element, attr, id) { 2870 var nu = filter(read$2(element, attr), function (v) { 2871 return v !== id; 2872 }); 2873 if (nu.length > 0) { 2874 set$1(element, attr, nu.join(' ')); 2875 } else { 2876 remove$1(element, attr); 2877 } 2878 return false; 2879 }; 2880 2881 var supports = function (element) { 2882 return element.dom.classList !== undefined; 2883 }; 2884 var get$4 = function (element) { 2885 return read$2(element, 'class'); 2886 }; 2887 var add$1 = function (element, clazz) { 2888 return add(element, 'class', clazz); 2889 }; 2890 var remove$3 = function (element, clazz) { 2891 return remove$2(element, 'class', clazz); 2892 }; 2893 2894 var add$2 = function (element, clazz) { 2895 if (supports(element)) { 2896 element.dom.classList.add(clazz); 2897 } else { 2898 add$1(element, clazz); 2899 } 2900 }; 2901 var cleanClass = function (element) { 2902 var classList = supports(element) ? element.dom.classList : get$4(element); 2903 if (classList.length === 0) { 2904 remove$1(element, 'class'); 2905 } 2906 }; 2907 var remove$4 = function (element, clazz) { 2908 if (supports(element)) { 2909 var classList = element.dom.classList; 2910 classList.remove(clazz); 2911 } else { 2912 remove$3(element, clazz); 2913 } 2914 cleanClass(element); 2915 }; 2916 var has$2 = function (element, clazz) { 2917 return supports(element) && element.dom.classList.contains(clazz); 2918 }; 2919 2920 var add$3 = function (element, classes) { 2921 each(classes, function (x) { 2922 add$2(element, x); 2923 }); 2924 }; 2925 var remove$5 = function (element, classes) { 2926 each(classes, function (x) { 2927 remove$4(element, x); 2928 }); 2929 }; 2930 2931 var isSupported$1 = function (dom) { 2932 return dom.style !== undefined && isFunction(dom.style.getPropertyValue); 2933 }; 2934 2935 var inBody = function (element) { 2936 var dom = isText(element) ? element.dom.parentNode : element.dom; 2937 if (dom === undefined || dom === null || dom.ownerDocument === null) { 2938 return false; 2939 } 2940 var doc = dom.ownerDocument; 2941 return getShadowRoot(SugarElement.fromDom(dom)).fold(function () { 2942 return doc.body.contains(dom); 2943 }, compose1(inBody, getShadowHost)); 2944 }; 2945 var body = function () { 2946 return getBody(SugarElement.fromDom(document)); 2947 }; 2948 var getBody = function (doc) { 2949 var b = doc.dom.body; 2950 if (b === null || b === undefined) { 2951 throw new Error('Body is not available yet'); 2952 } 2953 return SugarElement.fromDom(b); 2954 }; 2955 2956 var internalSet = function (dom, property, value) { 2957 if (!isString(value)) { 2958 console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom); 2959 throw new Error('CSS value must be a string: ' + value); 2960 } 2961 if (isSupported$1(dom)) { 2962 dom.style.setProperty(property, value); 2963 } 2964 }; 2965 var internalRemove = function (dom, property) { 2966 if (isSupported$1(dom)) { 2967 dom.style.removeProperty(property); 2968 } 2969 }; 2970 var set$2 = function (element, property, value) { 2971 var dom = element.dom; 2972 internalSet(dom, property, value); 2973 }; 2974 var setAll$1 = function (element, css) { 2975 var dom = element.dom; 2976 each$1(css, function (v, k) { 2977 internalSet(dom, k, v); 2978 }); 2979 }; 2980 var setOptions = function (element, css) { 2981 var dom = element.dom; 2982 each$1(css, function (v, k) { 2983 v.fold(function () { 2984 internalRemove(dom, k); 2985 }, function (value) { 2986 internalSet(dom, k, value); 2987 }); 2988 }); 2989 }; 2990 var get$5 = function (element, property) { 2991 var dom = element.dom; 2992 var styles = window.getComputedStyle(dom); 2993 var r = styles.getPropertyValue(property); 2994 return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r; 2995 }; 2996 var getUnsafeProperty = function (dom, property) { 2997 return isSupported$1(dom) ? dom.style.getPropertyValue(property) : ''; 2998 }; 2999 var getRaw = function (element, property) { 3000 var dom = element.dom; 3001 var raw = getUnsafeProperty(dom, property); 3002 return Optional.from(raw).filter(function (r) { 3003 return r.length > 0; 3004 }); 3005 }; 3006 var getAllRaw = function (element) { 3007 var css = {}; 3008 var dom = element.dom; 3009 if (isSupported$1(dom)) { 3010 for (var i = 0; i < dom.style.length; i++) { 3011 var ruleName = dom.style.item(i); 3012 css[ruleName] = dom.style[ruleName]; 3013 } 3014 } 3015 return css; 3016 }; 3017 var isValidValue = function (tag, property, value) { 3018 var element = SugarElement.fromTag(tag); 3019 set$2(element, property, value); 3020 var style = getRaw(element, property); 3021 return style.isSome(); 3022 }; 3023 var remove$6 = function (element, property) { 3024 var dom = element.dom; 3025 internalRemove(dom, property); 3026 if (getOpt(element, 'style').map(trim).is('')) { 3027 remove$1(element, 'style'); 3028 } 3029 }; 3030 var reflow = function (e) { 3031 return e.dom.offsetWidth; 3032 }; 3033 3034 var get$6 = function (element) { 3035 return element.dom.value; 3036 }; 3037 var set$3 = function (element, value) { 3038 if (value === undefined) { 3039 throw new Error('Value.set was undefined'); 3040 } 3041 element.dom.value = value; 3042 }; 3043 3044 var renderToDom = function (definition) { 3045 var subject = SugarElement.fromTag(definition.tag); 3046 setAll(subject, definition.attributes); 3047 add$3(subject, definition.classes); 3048 setAll$1(subject, definition.styles); 3049 definition.innerHtml.each(function (html) { 3050 return set(subject, html); 3051 }); 3052 var children = definition.domChildren; 3053 append$1(subject, children); 3054 definition.value.each(function (value) { 3055 set$3(subject, value); 3056 }); 3057 if (!definition.uid) { 3058 debugger; 3059 } 3060 writeOnly(subject, definition.uid); 3061 return subject; 3062 }; 3063 3064 var getBehaviours$1 = function (spec) { 3065 var behaviours = get$1(spec, 'behaviours').getOr({}); 3066 var keys$1 = filter(keys(behaviours), function (k) { 3067 return behaviours[k] !== undefined; 3068 }); 3069 return map(keys$1, function (k) { 3070 return behaviours[k].me; 3071 }); 3072 }; 3073 var generateFrom$1 = function (spec, all) { 3074 return generateFrom(spec, all); 3075 }; 3076 var generate$3 = function (spec) { 3077 var all = getBehaviours$1(spec); 3078 return generateFrom$1(spec, all); 3079 }; 3080 3081 var getDomDefinition = function (info, bList, bData) { 3082 var definition = toDefinition(info); 3083 var infoModification = toModification(info); 3084 var baseModification = { 'alloy.base.modification': infoModification }; 3085 var modification = bList.length > 0 ? combine(bData, baseModification, bList, definition) : infoModification; 3086 return merge$1(definition, modification); 3087 }; 3088 var getEvents = function (info, bList, bData) { 3089 var baseEvents = { 'alloy.base.behaviour': toEvents(info) }; 3090 return combine$1(bData, info.eventOrder, bList, baseEvents).getOrDie(); 3091 }; 3092 var build = function (spec) { 3093 var getMe = function () { 3094 return me; 3095 }; 3096 var systemApi = Cell(singleton); 3097 var info = getOrDie(toInfo(spec)); 3098 var bBlob = generate$3(spec); 3099 var bList = getBehaviours(bBlob); 3100 var bData = getData(bBlob); 3101 var modDefinition = getDomDefinition(info, bList, bData); 3102 var item = renderToDom(modDefinition); 3103 var events = getEvents(info, bList, bData); 3104 var subcomponents = Cell(info.components); 3105 var connect = function (newApi) { 3106 systemApi.set(newApi); 3107 }; 3108 var disconnect = function () { 3109 systemApi.set(NoContextApi(getMe)); 3110 }; 3111 var syncComponents = function () { 3112 var children$1 = children(item); 3113 var subs = bind(children$1, function (child) { 3114 return systemApi.get().getByDom(child).fold(function () { 3115 return []; 3116 }, function (c) { 3117 return [c]; 3118 }); 3119 }); 3120 subcomponents.set(subs); 3121 }; 3122 var config = function (behaviour) { 3123 var b = bData; 3124 var f = isFunction(b[behaviour.name()]) ? b[behaviour.name()] : function () { 3125 throw new Error('Could not find ' + behaviour.name() + ' in ' + JSON.stringify(spec, null, 2)); 3126 }; 3127 return f(); 3128 }; 3129 var hasConfigured = function (behaviour) { 3130 return isFunction(bData[behaviour.name()]); 3131 }; 3132 var getApis = function () { 3133 return info.apis; 3134 }; 3135 var readState = function (behaviourName) { 3136 return bData[behaviourName]().map(function (b) { 3137 return b.state.readState(); 3138 }).getOr('not enabled'); 3139 }; 3140 var me = { 3141 getSystem: systemApi.get, 3142 config: config, 3143 hasConfigured: hasConfigured, 3144 spec: spec, 3145 readState: readState, 3146 getApis: getApis, 3147 connect: connect, 3148 disconnect: disconnect, 3149 element: item, 3150 syncComponents: syncComponents, 3151 components: subcomponents.get, 3152 events: events 3153 }; 3154 return me; 3155 }; 3156 3157 var buildSubcomponents = function (spec) { 3158 var components = get$1(spec, 'components').getOr([]); 3159 return map(components, build$1); 3160 };
3161 var buildFromSpec = function (userSpec) { 3162 var _a = make(userSpec), specEvents = _a.events, spec = __rest(_a, ['events']); 3163 var components = buildSubcomponents(spec); 3164 var completeSpec = __assign(__assign({}, spec), { 3165 events: __assign(__assign({}, DefaultEvents), specEvents), 3166 components: components 3167 }); 3168 return Result.value(build(completeSpec)); 3169 }; 3170 var text = function (textContent) { 3171 var element = SugarElement.fromText(textContent); 3172 return external({ element: element }); 3173 }; 3174 var external = function (spec) { 3175 var extSpec = asRawOrDie('external.component', objOfOnly([ 3176 strict$1('element'), 3177 option('uid') 3178 ]), spec); 3179 var systemApi = Cell(NoContextApi()); 3180 var connect = function (newApi) { 3181 systemApi.set(newApi); 3182 }; 3183 var disconnect = function () { 3184 systemApi.set(NoContextApi(function () { 3185 return me; 3186 })); 3187 }; 3188 extSpec.uid.each(function (uid) { 3189 writeOnly(extSpec.element, uid); 3190 }); 3191 var me = { 3192 getSystem: systemApi.get, 3193 config: Optional.none, 3194 hasConfigured: never, 3195 connect: connect, 3196 disconnect: disconnect, 3197 getApis: function () { 3198 return {}; 3199 }, 3200 element: extSpec.element, 3201 spec: spec, 3202 readState: constant('No state'), 3203 syncComponents: noop, 3204 components: constant([]), 3205 events: {} 3206 }; 3207 return premade(me); 3208 }; 3209 var uids = generate$2; 3210 var build$1 = function (spec) { 3211 return getPremade(spec).fold(function () { 3212 var userSpecWithUid = spec.hasOwnProperty('uid') ? spec : __assign({ uid: uids('') }, spec); 3213 return buildFromSpec(userSpecWithUid).getOrDie(); 3214 }, function (prebuilt) { 3215 return prebuilt; 3216 }); 3217 }; 3218 var premade$1 = premade; 3219 3220 var Dimension = function (name, getOffset) { 3221 var set = function (element, h) { 3222 if (!isNumber(h) && !h.match(/^[0-9]+$/)) { 3223 throw new Error(name + '.set accepts only positive integer values. Value was ' + h); 3224 } 3225 var dom = element.dom; 3226 if (isSupported$1(dom)) { 3227 dom.style[name] = h + 'px'; 3228 } 3229 }; 3230 var get = function (element) { 3231 var r = getOffset(element); 3232 if (r <= 0 || r === null) { 3233 var css = get$5(element, name); 3234 return parseFloat(css) || 0; 3235 } 3236 return r; 3237 }; 3238 var getOuter = get; 3239 var aggregate = function (element, properties) { 3240 return foldl(properties, function (acc, property) { 3241 var val = get$5(element, property); 3242 var value = val === undefined ? 0 : parseInt(val, 10); 3243 return isNaN(value) ? acc : acc + value; 3244 }, 0); 3245 }; 3246 var max = function (element, value, properties) { 3247 var cumulativeInclusions = aggregate(element, properties); 3248 var absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0; 3249 return absoluteMax; 3250 }; 3251 return { 3252 set: set, 3253 get: get, 3254 getOuter: getOuter, 3255 aggregate: aggregate, 3256 max: max 3257 }; 3258 }; 3259 3260 var api = Dimension('height', function (element) { 3261 var dom = element.dom; 3262 return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight; 3263 }); 3264 var get$7 = function (element) { 3265 return api.get(element); 3266 }; 3267 var getOuter$1 = function (element) { 3268 return api.getOuter(element); 3269 }; 3270 var setMax = function (element, value) { 3271 var inclusions = [ 3272 'margin-top', 3273 'border-top-width', 3274 'padding-top', 3275 'padding-bottom', 3276 'border-bottom-width', 3277 'margin-bottom' 3278 ]; 3279 var absMax = api.max(element, value, inclusions); 3280 set$2(element, 'max-height', absMax + 'px'); 3281 }; 3282 3283 var r = function (left, top) { 3284 var translate = function (x, y) { 3285 return r(left + x, top + y); 3286 }; 3287 return { 3288 left: left, 3289 top: top, 3290 translate: translate 3291 }; 3292 }; 3293 var SugarPosition = r; 3294 3295 var boxPosition = function (dom) { 3296 var box = dom.getBoundingClientRect(); 3297 return SugarPosition(box.left, box.top); 3298 }; 3299 var firstDefinedOrZero = function (a, b) { 3300 if (a !== undefined) { 3301 return a; 3302 } else { 3303 return b !== undefined ? b : 0; 3304 } 3305 }; 3306 var absolute = function (element) { 3307 var doc = element.dom.ownerDocument; 3308 var body = doc.body; 3309 var win = doc.defaultView; 3310 var html = doc.documentElement; 3311 if (body === element.dom) { 3312 return SugarPosition(body.offsetLeft, body.offsetTop); 3313 } 3314 var scrollTop = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageYOffset, html.scrollTop);
3315 var scrollLeft = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageXOffset, html.scrollLeft); 3316 var clientTop = firstDefinedOrZero(html.clientTop, body.clientTop); 3317 var clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft); 3318 return viewport(element).translate(scrollLeft - clientLeft, scrollTop - clientTop); 3319 }; 3320 var viewport = function (element) { 3321 var dom = element.dom; 3322 var doc = dom.ownerDocument; 3323 var body = doc.body; 3324 if (body === dom) { 3325 return SugarPosition(body.offsetLeft, body.offsetTop); 3326 } 3327 if (!inBody(element)) { 3328 return SugarPosition(0, 0); 3329 } 3330 return boxPosition(dom); 3331 }; 3332 3333 var api$1 = Dimension('width', function (element) { 3334 return element.dom.offsetWidth; 3335 }); 3336 var set$4 = function (element, h) { 3337 return api$1.set(element, h); 3338 }; 3339 var get$8 = function (element) { 3340 return api$1.get(element); 3341 }; 3342 var getOuter$2 = function (element) { 3343 return api$1.getOuter(element); 3344 }; 3345 var setMax$1 = function (element, value) { 3346 var inclusions = [ 3347 'margin-left', 3348 'border-left-width', 3349 'padding-left', 3350 'padding-right', 3351 'border-right-width', 3352 'margin-right' 3353 ]; 3354 var absMax = api$1.max(element, value, inclusions); 3355 set$2(element, 'max-width', absMax + 'px'); 3356 }; 3357 3358 var mkEvent = function (target, x, y, stop, prevent, kill, raw) { 3359 return { 3360 target: target, 3361 x: x, 3362 y: y, 3363 stop: stop, 3364 prevent: prevent, 3365 kill: kill, 3366 raw: raw 3367 }; 3368 }; 3369 var fromRawEvent = function (rawEvent) { 3370 var target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target)); 3371 var stop = function () { 3372 return rawEvent.stopPropagation(); 3373 }; 3374 var prevent = function () { 3375 return rawEvent.preventDefault(); 3376 }; 3377 var kill = compose(prevent, stop); 3378 return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent); 3379 }; 3380 var handle = function (filter, handler) { 3381 return function (rawEvent) { 3382 if (filter(rawEvent)) { 3383 handler(fromRawEvent(rawEvent)); 3384 } 3385 }; 3386 }; 3387 var binder = function (element, event, filter, handler, useCapture) { 3388 var wrapped = handle(filter, handler); 3389 element.dom.addEventListener(event, wrapped, useCapture); 3390 return { unbind: curry(unbind, element, event, wrapped, useCapture) }; 3391 }; 3392 var bind$2 = function (element, event, filter, handler) { 3393 return binder(element, event, filter, handler, false); 3394 }; 3395 var capture = function (element, event, filter, handler) { 3396 return binder(element, event, filter, handler, true); 3397 }; 3398 var unbind = function (element, event, handler, useCapture) { 3399 element.dom.removeEventListener(event, handler, useCapture); 3400 }; 3401 3402 var get$9 = function (_DOC) { 3403 var doc = _DOC !== undefined ? _DOC.dom : document; 3404 var x = doc.body.scrollLeft || doc.documentElement.scrollLeft; 3405 var y = doc.body.scrollTop || doc.documentElement.scrollTop; 3406 return SugarPosition(x, y); 3407 }; 3408 var to = function (x, y, _DOC) { 3409 var doc = _DOC !== undefined ? _DOC.dom : document; 3410 var win = doc.defaultView; 3411 if (win) { 3412 win.scrollTo(x, y); 3413 } 3414 }; 3415 3416 var get$a = function (_win) { 3417 var win = _win === undefined ? window : _win; 3418 return Optional.from(win['visualViewport']); 3419 }; 3420 var bounds = function (x, y, width, height) { 3421 return { 3422 x: x, 3423 y: y, 3424 width: width, 3425 height: height, 3426 right: x + width, 3427 bottom: y + height 3428 }; 3429 }; 3430 var getBounds = function (_win) { 3431 var win = _win === undefined ? window : _win; 3432 var doc = win.document; 3433 var scroll = get$9(SugarElement.fromDom(doc)); 3434 return get$a(win).fold(function () { 3435 var html = win.document.documentElement; 3436 var width = html.clientWidth; 3437 var height = html.clientHeight; 3438 return bounds(scroll.left, scroll.top, width, height); 3439 }
3439, function (visualViewport) { 3440 return bounds(Math.max(visualViewport.pageLeft, scroll.left), Math.max(visualViewport.pageTop, scroll.top), visualViewport.width, visualViewport.height); 3441 }); 3442 }; 3443 3444 var walkUp = function (navigation, doc) { 3445 var frame = navigation.view(doc); 3446 return frame.fold(constant([]), function (f) { 3447 var parent = navigation.owner(f); 3448 var rest = walkUp(navigation, parent); 3449 return [f].concat(rest); 3450 }); 3451 }; 3452 var pathTo = function (element, navigation) { 3453 var d = navigation.owner(element); 3454 var paths = walkUp(navigation, d); 3455 return Optional.some(paths); 3456 }; 3457 3458 var view = function (doc) { 3459 var _a; 3460 var element = doc.dom === document ? Optional.none() : Optional.from((_a = doc.dom.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement); 3461 return element.map(SugarElement.fromDom); 3462 }; 3463 var owner$1 = function (element) { 3464 return owner(element); 3465 }; 3466 3467 var Navigation = /*#__PURE__*/Object.freeze({ 3468 __proto__: null, 3469 view: view, 3470 owner: owner$1 3471 }); 3472 3473 var find$3 = function (element) { 3474 var doc = SugarElement.fromDom(document); 3475 var scroll = get$9(doc); 3476 var path = pathTo(element, Navigation); 3477 return path.fold(curry(absolute, element), function (frames) { 3478 var offset = viewport(element); 3479 var r = foldr(frames, function (b, a) { 3480 var loc = viewport(a); 3481 return { 3482 left: b.left + loc.left, 3483 top: b.top + loc.top 3484 }; 3485 }, { 3486 left: 0, 3487 top: 0 3488 }); 3489 return SugarPosition(r.left + offset.left + scroll.left, r.top + offset.top + scroll.top); 3490 }); 3491 }; 3492 3493 var pointed = function (point, width, height) { 3494 return { 3495 point: point, 3496 width: width, 3497 height: height 3498 }; 3499 }; 3500 var rect = function (x, y, width, height) { 3501 return { 3502 x: x, 3503 y: y, 3504 width: width, 3505 height: height 3506 }; 3507 }; 3508 var bounds$1 = function (x, y, width, height) { 3509 return { 3510 x: x, 3511 y: y, 3512 width: width, 3513 height: height, 3514 right: x + width, 3515 bottom: y + height 3516 }; 3517 }; 3518 var box = function (element) { 3519 var xy = absolute(element); 3520 var w = getOuter$2(element); 3521 var h = getOuter$1(element); 3522 return bounds$1(xy.left, xy.top, w, h); 3523 }; 3524 var absolute$1 = function (element) { 3525 var position = find$3(element); 3526 var width = getOuter$2(element); 3527 var height = getOuter$1(element); 3528 return bounds$1(position.left, position.top, width, height); 3529 }; 3530 var win = function () { 3531 return getBounds(window); 3532 }; 3533 3534 function ClosestOrAncestor (is, ancestor, scope, a, isRoot) { 3535 if (is(scope, a)) { 3536 return Optional.some(scope); 3537 } else if (isFunction(isRoot) && isRoot(scope)) { 3538 return Optional.none(); 3539 } else { 3540 return ancestor(scope, a, isRoot); 3541 } 3542 } 3543 3544 var ancestor$1 = function (scope, predicate, isRoot) { 3545 var element = scope.dom; 3546 var stop = isFunction(isRoot) ? isRoot : never; 3547 while (element.parentNode) { 3548 element = element.parentNode; 3549 var el = SugarElement.fromDom(element); 3550 if (predicate(el)) { 3551 return Optional.some(el); 3552 } else if (stop(el)) { 3553 break; 3554 } 3555 } 3556 return Optional.none(); 3557 }; 3558 var closest$1 = function (scope, predicate, isRoot) { 3559 var is = function (s, test) { 3560 return test(s); 3561 }; 3562 return ClosestOrAncestor(is, ancestor$1, scope, predicate, isRoot); 3563 }; 3564 var descendant = function (scope, predicate) { 3565 var descend = function (node) { 3566 for (var i = 0; i < node.childNodes.length; i++) { 3567 var child_1 = SugarElement.fromDom(node.childNodes[i]); 3568 if (predicate(child_1)) { 3569 return Optional.some(child_1); 3570 } 3571 var res = descend(node.childNodes[i]); 3572 if (res.isSome()) { 3573 return res; 3574 } 3575 } 3576 return Optional.none(); 3577 }; 3578 return descend(scope.dom); 3579 }; 3580 3581 var closest$2 = function (scope, predicate, isRoot) { 3582 return closest$1(scope, predicate, isRoot).isSome(); 3583 }; 3584 3585 var ancestor$2 = function (scope, selector, isRoot) { 3586 return ancestor$1(scope, function (e) { 3587 return is(e, selector); 3588 }, isRoot); 3589 }; 3590 var descendant$1 = function (scope, selector) { 3591 return one(selector, scope); 3592 }; 3593 var closest$3 = function (scope, selector, isRoot) { 3594 var is$1 = function (element, selector) { 3595 return is(element, selector); 3596 }; 3597 return ClosestOrAncestor(is$1, ancestor$2, scope, selector, isRoot); 3598 }; 3599 3600 var find$4 = function (queryElem) { 3601 var dependent = closest$1(queryElem, function (elem) { 3602 if (!isElement(elem)) { 3603 return false;
3604 } 3605 var id = get$3(elem, 'id'); 3606 return id !== undefined && id.indexOf('aria-owns') > -1; 3607 }); 3608 return dependent.bind(function (dep) { 3609 var id = get$3(dep, 'id'); 3610 var dos = getRootNode(dep); 3611 return descendant$1(dos, '[aria-owns="' + id + '"]'); 3612 }); 3613 }; 3614 var manager = function () { 3615 var ariaId = generate$1('aria-owns'); 3616 var link = function (elem) { 3617 set$1(elem, 'aria-owns', ariaId); 3618 }; 3619 var unlink = function (elem) { 3620 remove$1(elem, 'aria-owns'); 3621 }; 3622 return { 3623 id: ariaId, 3624 link: link, 3625 unlink: unlink 3626 }; 3627 }; 3628 3629 var isAriaPartOf = function (component, queryElem) { 3630 return find$4(queryElem).exists(function (owner) { 3631 return isPartOf(component, owner); 3632 }); 3633 }; 3634 var isPartOf = function (component, queryElem) { 3635 return closest$2(queryElem, function (el) { 3636 return eq$1(el, component.element); 3637 }, never) || isAriaPartOf(component, queryElem); 3638 }; 3639 3640 var unknown$3 = 'unknown'; 3641 var EventConfiguration; 3642 (function (EventConfiguration) { 3643 EventConfiguration[EventConfiguration['STOP'] = 0] = 'STOP'; 3644 EventConfiguration[EventConfiguration['NORMAL'] = 1] = 'NORMAL'; 3645 EventConfiguration[EventConfiguration['LOGGING'] = 2] = 'LOGGING'; 3646 }(EventConfiguration || (EventConfiguration = {}))); 3647 var eventConfig = Cell({}); 3648 var makeEventLogger = function (eventName, initialTarget) { 3649 var sequence = []; 3650 var startTime = new Date().getTime(); 3651 return { 3652 logEventCut: function (_name, target, purpose) { 3653 sequence.push({ 3654 outcome: 'cut', 3655 target: target, 3656 purpose: purpose 3657 }); 3658 }, 3659 logEventStopped: function (_name, target, purpose) { 3660 sequence.push({ 3661 outcome: 'stopped', 3662 target: target, 3663 purpose: purpose 3664 }); 3665 }, 3666 logNoParent: function (_name, target, purpose) { 3667 sequence.push({ 3668 outcome: 'no-parent', 3669 target: target, 3670 purpose: purpose 3671 }); 3672 }, 3673 logEventNoHandlers: function (_name, target) { 3674 sequence.push({ 3675 outcome: 'no-handlers-left', 3676 target: target 3677 }); 3678 }, 3679 logEventResponse: function (_name, target, purpose) { 3680 sequence.push({ 3681 outcome: 'response', 3682 purpose: purpose, 3683 target: target 3684 }); 3685 }, 3686 write: function () { 3687 var finishTime = new Date().getTime(); 3688 if (contains([ 3689 'mousemove', 3690 'mouseover', 3691 'mouseout', 3692 systemInit() 3693 ], eventName)) { 3694 return; 3695 } 3696 console.log(eventName, { 3697 event: eventName, 3698 time: finishTime - startTime, 3699 target: initialTarget.dom, 3700 sequence: map(sequence, function (s) { 3701 if (!contains([ 3702 'cut', 3703 'stopped', 3704 'response' 3705 ], s.outcome)) { 3706 return s.outcome; 3707 } else { 3708 return '{' + s.purpose + '} ' + s.outcome + ' at (' + element(s.target) + ')'; 3709 } 3710 }) 3711 }); 3712 } 3713 }; 3714 }; 3715 var processEvent = function (eventName, initialTarget, f) { 3716 var status = get$1(eventConfig.get(), eventName).orThunk(function () { 3717 var patterns = keys(eventConfig.get()); 3718 return findMap(patterns, function (p) { 3719 return eventName.indexOf(p) > -1 ? Optional.some(eventConfig.get()[p]) : Optional.none(); 3720 }); 3721 }).getOr(EventConfiguration.NORMAL); 3722 switch (status) { 3723 case EventConfiguration.NORMAL: 3724 return f(noLogger()); 3725 case EventConfiguration.LOGGING: { 3726 var logger = makeEventLogger(eventName, initialTarget); 3727 var output = f(logger); 3728 logger.write(); 3729 return output; 3730 } 3731 case EventConfiguration.STOP: 3732 return true; 3733 } 3734 }; 3735 var path = [ 3736 'alloy/data/Fields', 3737 'alloy/debugging/Debugging' 3738 ]; 3739 var getTrace = function () { 3740 var err = new Error(); 3741 if (err.stack !== undefined) { 3742 var lines = err.stack.split('\n'); 3743 return find(lines, function (line) { 3744 return line.indexOf('alloy') > 0 && !exists(path, function (p) { 3745 return line.indexOf(p) > -1; 3746 }); 3747 }).getOr(unknown$3); 3748 } else { 3749 return unknown$3; 3750 } 3751 }; 3752 var ignoreEvent = { 3753 logEventCut: noop, 3754 logEventStopped: noop, 3755 logNoParent: noop, 3756 logEventNoHandlers: noop, 3757 logEventResponse: noop, 3758 write: noop 3759 }; 3760 var monitorEvent = function (eventName, initialTarget, f) { 3761 return processEvent(eventName, initialTarget, f); 3762 }; 3763 var noLogger = constant(ignoreEvent); 3764 3765 var menuFields = constant([
3766 strict$1('menu'), 3767 strict$1('selectedMenu') 3768 ]); 3769 var itemFields = constant([ 3770 strict$1('item'), 3771 strict$1('selectedItem') 3772 ]); 3773 var schema = constant(objOf(itemFields().concat(menuFields()))); 3774 var itemSchema = constant(objOf(itemFields())); 3775 3776 var _initSize = strictObjOf('initSize', [ 3777 strict$1('numColumns'), 3778 strict$1('numRows') 3779 ]); 3780 var itemMarkers = function () { 3781 return strictOf('markers', itemSchema()); 3782 }; 3783 var tieredMenuMarkers = function () { 3784 return strictObjOf('markers', [strict$1('backgroundMenu')].concat(menuFields()).concat(itemFields())); 3785 }; 3786 var markers = function (required) { 3787 return strictObjOf('markers', map(required, strict$1)); 3788 }; 3789 var onPresenceHandler = function (label, fieldName, presence) { 3790 var trace = getTrace(); 3791 return field(fieldName, fieldName, presence, valueOf(function (f) { 3792 return Result.value(function () { 3793 var args = []; 3794 for (var _i = 0; _i < arguments.length; _i++) { 3795 args[_i] = arguments[_i]; 3796 } 3797 return f.apply(undefined, args); 3798 }); 3799 })); 3800 }; 3801 var onHandler = function (fieldName) { 3802 return onPresenceHandler('onHandler', fieldName, defaulted(noop)); 3803 }; 3804 var onKeyboardHandler = function (fieldName) { 3805 return onPresenceHandler('onKeyboardHandler', fieldName, defaulted(Optional.none)); 3806 }; 3807 var onStrictHandler = function (fieldName) { 3808 return onPresenceHandler('onHandler', fieldName, strict()); 3809 }; 3810 var onStrictKeyboardHandler = function (fieldName) { 3811 return onPresenceHandler('onKeyboardHandler', fieldName, strict()); 3812 }; 3813 var output = function (name, value) { 3814 return state$1(name, constant(value)); 3815 }; 3816 var snapshot = function (name) { 3817 return state$1(name, identity); 3818 }; 3819 var initSize = constant(_initSize); 3820 3821 var nu$7 = function (x, y, bubble, direction, boundsRestriction, label) { 3822 return { 3823 x: x, 3824 y: y, 3825 bubble: bubble, 3826 direction: direction, 3827 boundsRestriction: boundsRestriction, 3828 label: label 3829 }; 3830 }; 3831 3832 var adt$2 = Adt.generate([ 3833 { southeast: [] }, 3834 { southwest: [] }, 3835 { northeast: [] }, 3836 { northwest: [] }, 3837 { south: [] }, 3838 { north: [] }, 3839 { east: [] }, 3840 { west: [] } 3841 ]); 3842 var cata = function (subject, southeast, southwest, northeast, northwest, south, north, east, west) { 3843 return subject.fold(southeast, southwest, northeast, northwest, south, north, east, west); 3844 }; 3845 var cataVertical = function (subject, south, middle, north) { 3846 return subject.fold(south, south, north, north, south, north, middle, middle); 3847 }; 3848 var cataHorizontal = function (subject, east, middle, west) { 3849 return subject.fold(east, west, east, west, middle, middle, east, west); 3850 }; 3851 var southeast = adt$2.southeast; 3852 var southwest = adt$2.southwest; 3853 var northeast = adt$2.northeast; 3854 var northwest = adt$2.northwest; 3855 var south = adt$2.south; 3856 var north = adt$2.north; 3857 var east = adt$2.east; 3858 var west = adt$2.west; 3859 3860 var getRestriction = function (anchor, restriction) { 3861 switch (restriction) { 3862 case 1: 3863 return anchor.x; 3864 case 0: 3865 return anchor.x + anchor.width; 3866 case 2: 3867 return anchor.y; 3868 case 3: 3869 return anchor.y + anchor.height; 3870 } 3871 }; 3872 var boundsRestriction = function (anchor, restrictions) { 3873 return mapToObject([ 3874 'left', 3875 'right', 3876 'top', 3877 'bottom' 3878 ], function (dir) { 3879 return get$1(restrictions, dir).map(function (restriction) { 3880 return getRestriction(anchor, restriction); 3881 }); 3882 }); 3883 }; 3884 var adjustBounds = function (bounds, boundsRestrictions, bubbleOffsets) { 3885 var applyRestriction = function (dir, current) { 3886 var bubbleOffset = dir === 'top' || dir === 'bottom' ? bubbleOffsets.top : bubbleOffsets.left; 3887 return get$1(boundsRestrictions, dir).bind(identity).bind(function (restr
3887iction) { 3888 if (dir === 'left' || dir === 'top') { 3889 return restriction >= current ? Optional.some(restriction) : Optional.none(); 3890 } else { 3891 return restriction <= current ? Optional.some(restriction) : Optional.none(); 3892 } 3893 }).map(function (restriction) { 3894 return restriction + bubbleOffset; 3895 }).getOr(current); 3896 }; 3897 var adjustedLeft = applyRestriction('left', bounds.x); 3898 var adjustedTop = applyRestriction('top', bounds.y); 3899 var adjustedRight = applyRestriction('right', bounds.right); 3900 var adjustedBottom = applyRestriction('bottom', bounds.bottom); 3901 return bounds$1(adjustedLeft, adjustedTop, adjustedRight - adjustedLeft, adjustedBottom - adjustedTop); 3902 }; 3903 3904 var eastX = function (anchor) { 3905 return anchor.x; 3906 }; 3907 var middleX = function (anchor, element) { 3908 return anchor.x + anchor.width / 2 - element.width / 2; 3909 }; 3910 var westX = function (anchor, element) { 3911 return anchor.x + anchor.width - element.width; 3912 }; 3913 var northY = function (anchor, element) { 3914 return anchor.y - element.height; 3915 }; 3916 var southY = function (anchor) { 3917 return anchor.y + anchor.height; 3918 }; 3919 var centreY = function (anchor, element) { 3920 return anchor.y + anchor.height / 2 - element.height / 2; 3921 }; 3922 var eastEdgeX = function (anchor) { 3923 return anchor.x + anchor.width; 3924 }; 3925 var westEdgeX = function (anchor, element) { 3926 return anchor.x - element.width; 3927 }; 3928 var southeast$1 = function (anchor, element, bubbles) { 3929 return nu$7(eastX(anchor), southY(anchor), bubbles.southeast(), southeast(), boundsRestriction(anchor, { 3930 left: 1, 3931 top: 3 3932 }), 'layout-se'); 3933 }; 3934 var southwest$1 = function (anchor, element, bubbles) { 3935 return nu$7(westX(anchor, element), southY(anchor), bubbles.southwest(), southwest(), boundsRestriction(anchor, { 3936 right: 0, 3937 top: 3 3938 }), 'layout-sw'); 3939 }; 3940 var northeast$1 = function (anchor, element, bubbles) { 3941 return nu$7(eastX(anchor), northY(anchor, element), bubbles.northeast(), northeast(), boundsRestriction(anchor, { 3942 left: 1, 3943 bottom: 2 3944 }), 'layout-ne'); 3945 }; 3946 var northwest$1 = function (anchor, element, bubbles) { 3947 return nu$7(westX(anchor, element), northY(anchor, element), bubbles.northwest(), northwest(), boundsRestriction(anchor, { 3948 right: 0, 3949 bottom: 2 3950 }), 'layout-nw'); 3951 }; 3952 var north$1 = function (anchor, element, bubbles) { 3953 return nu$7(middleX(anchor, element), northY(anchor, element), bubbles.north(), north(), boundsRestriction(anchor, { bottom: 2 }), 'layout-n'); 3954 }; 3955 var south$1 = function (anchor, element, bubbles) { 3956 return nu$7(middleX(anchor, element), southY(anchor), bubbles.south(), south(), boundsRestriction(anchor, { top: 3 }), 'layout-s'); 3957 }; 3958 var east$1 = function (anchor, element, bubbles) { 3959 return nu$7(eastEdgeX(anchor), centreY(anchor, element), bubbles.east(), east(), boundsRestriction(anchor, { left: 0 }), 'layout-e'); 3960 }; 3961 var west$1 = function (anchor, element, bubbles) { 3962 return nu$7(westEdgeX(anchor, element), centreY(anchor, element), bubbles.west(), west(), boundsRestriction(anchor, { right: 1 }), 'layout-w'); 3963 }; 3964 var all$2 = function () { 3965 return [ 3966 southeast$1, 3967 southwest$1, 3968 northeast$1, 3969 northwest$1, 3970 south$1, 3971 north$1, 3972 east$1, 3973 west$1 3974 ]; 3975 }; 3976 var allRtl = function () { 3977 return [ 3978 southwest$1, 3979 southeast$1, 3980 northwest$1, 3981 northeast$1, 3982 south$1, 3983 north$1, 3984 east$1, 3985 west$1 3986 ]; 3987 }; 3988 var aboveOrBelow = function () { 3989 return [ 3990 northeast$1, 3991 northwest$1, 3992 southeast$1, 3993 southwest$1, 3994 north$1, 3995 south$1 3996 ]; 3997 }; 3998 var aboveOrBelowRtl = function () { 3999 return [ 4000 northwest$1, 4001 northeast$1, 4002 southwest$1, 4003 southeast$1, 4004 north$1, 4005 south$1 4006 ]; 4007 }; 4008 var belowOrAbove = function () { 4009 return [ 4010 southeast$1, 4011 southwest$1, 4012 northeast$1, 4013 northwest$1, 4014 south$1, 4015 north$1 4016 ]; 4017 }; 4018 var belowOrAboveRtl = function () { 4019 return [ 4020 southwest$1, 4021 southeast$1, 4022 northwest$1, 4023 northeast$1, 4024 south$1, 4025 north$1 4026 ]; 4027 }; 4028 4029 var chooseChannels = function (channels, message) { 4030 return message.universal ? channels : filter(channels, function (ch) { 4031 return contains(message.channels, ch); 4032 }); 4033 }; 4034 var events$1 = function (receiveConfig) { 4035 return derive([run(receive(), function (component, message) { 4036 var channelMap = receiveConfig.channels; 4037 var channels = keys(channelMap); 4038 var receivingData = message; 4039 var targetChannels = chooseChannels(channels, receivingData); 4040 each(targetChannels, function (ch) { 4041 var channelInfo = channelMap[ch]; 4042 var channelSchema = channelInfo.schema; 4043 var data = asRawOrDie('channel[' + ch + '] data\nReceiver: ' + element(component.element), channelSchema, receivingData.data); 4044 channelInfo.onReceive(component, data); 4045 }); 4046 })]); 4047 }; 4048 4049 var ActiveReceiving = /*#__PURE__*/Object.freeze({ 4050 __proto__: null, 4051 events: events$1 4052 }); 4053 4054 var ReceivingSchema = [strictOf('channels', setOf$1(Result.value, objOfOnly([ 4055 onStrictHandler('onReceive'), 4056 defaulted$1('schema', anyValue$1()) 4057 ])))]; 4058 4059 var executeEvent = function (bConfig, bState, executor) { 4060 return runOnExecute(function (component) { 4061 executor(component, bConfig, bState); 4062 }); 4063 }; 4064 var loadEvent = function (bConfig, bState, f) { 4065 return runOnInit(function (component, _simulatedEvent) { 4066 f(component, bConfig, bState); 4067 }); 4068 }; 4069 var create = function (schema, name, active, apis, extra, state) { 4070 var configSchema = objOfOnly(schema); 4071 var schemaSchema = optionObjOf(name, [optionObjOfOnly('config', schema)]); 4072 return doCreate(configSchema, schemaSchema, name, active, apis, extra, state); 4073 }; 4074 var createModes = function (modes, name, active, apis, extra, state) { 4075 var configSchema = modes; 4076 var schemaSchema = optionObjOf(name, [optionOf('config', modes)]); 4077 return doCreate(configSchema, schemaSchema, name, active, apis, extra, state); 4078 }; 4079 var wrapApi = function (bName, apiFunction, apiName) { 4080 var f = function (component) { 4081 var rest = []; 4082 for (var _i = 1; _i < arguments.length; _i++) { 4083 rest[_i - 1] = arguments[_i]; 4084 } 4085 var args = [component].concat(rest); 4086 return component.config({ name: constant(bName) }).fold(function () { 4087 throw new Error('We could not find any behaviour configuration for: ' + bName + '. Using API: ' + apiName); 4088 }, function (info) { 4089 var rest = Array.prototype.slice.call(args, 1); 4090 return apiFunction.apply(undefined, [ 4091 component, 4092 info.config, 4093 info.state 4094 ].concat(rest)); 4095 }); 4096 }; 4097 return markAsBehaviourApi(f, apiName, apiFunction); 4098 }; 4099 var revokeBehaviour = function (name) { 4100 return { 4101 key: name, 4102 value: undefined 4103 }; 4104 }; 4105 var doCreate = function (configSchema, schemaSchema, name, active, apis, extra, state) { 4106 var getConfig = function (info) { 4107 return hasNonNullableKey(info, name) ? info[name]() : Optional.none(); 4108 }; 4109 var wrappedApis = map$2(apis, function (apiF, apiName) { 4110 return wrapApi(name, apiF, apiName); 4111 }); 4112 var wrappedExtra = map$2(extra, function (extraF, extraName) { 4113 return markAsExtraApi(extraF, extraName); 4114 }); 4115 var me = __assign(__assign(__assign({}, wrappedExtra), wrappedApis), { 4116 revoke: curry(revokeBehaviour, name), 4117 config: function (spec) { 4118 var prepared = asRawOrDie(name + '-config', configSchema, spec); 4119 return { 4120 key: name, 4121 value: { 4122 config: prepared, 4123 me: me, 4124 configAsRaw: cached(function () { 4125 return asRawOrDie(name + '-config', configSchema, spec); 4126 }), 4127 initialConfig: spec, 4128 state: state 4129 } 4130 }; 4131 }, 4132 schema: constant(schemaSchema), 4133 exhibit: function (info, base) { 4134 return getConfig(info).bind(function (behaviourInfo) { 4135 return get$1(active, 'exhibit').map(function (exhibitor) { 4136 return exhibitor(base, behaviourInfo.config, behaviourInfo.state); 4137 }); 4138 }).getOr(nu$6({})); 4139 }, 4140 name: constant(name), 4141 handlers: function (info) { 4142 return getConfig(info).map(function (behaviourInfo) { 4143 var getEvents = get$1(active, 'events').getOr(function () { 4144 return {}; 4145 }); 4146 return getEvents(behaviourInfo.config, behaviourInfo.state); 4147 }).getOr({}); 4148 } 4149 }); 4150 return me; 4151 }; 4152 4153 var derive$1 = function (capabilities) { 4154 return wrapAll$1(capabilities); 4155 }; 4156 var simpleSchema = objOfOnly([
4157 strict$1('fields'), 4158 strict$1('name'), 4159 defaulted$1('active', {}), 4160 defaulted$1('apis', {}), 4161 defaulted$1('state', NoState), 4162 defaulted$1('extra', {}) 4163 ]); 4164 var create$1 = function (data) { 4165 var value = asRawOrDie('Creating behaviour: ' + data.name, simpleSchema, data); 4166 return create(value.fields, value.name, value.active, value.apis, value.extra, value.state); 4167 }; 4168 var modeSchema = objOfOnly([ 4169 strict$1('branchKey'), 4170 strict$1('branches'), 4171 strict$1('name'), 4172 defaulted$1('active', {}), 4173 defaulted$1('apis', {}), 4174 defaulted$1('state', NoState), 4175 defaulted$1('extra', {}) 4176 ]); 4177 var createModes$1 = function (data) { 4178 var value = asRawOrDie('Creating behaviour: ' + data.name, modeSchema, data); 4179 return createModes(choose$1(value.branchKey, value.branches), value.name, value.active, value.apis, value.extra, value.state); 4180 }; 4181 var revoke = constant(undefined); 4182 4183 var Receiving = create$1({ 4184 fields: ReceivingSchema, 4185 name: 'receiving', 4186 active: ActiveReceiving 4187 }); 4188 4189 var exhibit = function (base, posConfig) { 4190 return nu$6({ 4191 classes: [], 4192 styles: posConfig.useFixed() ? {} : { position: 'relative' } 4193 }); 4194 }; 4195 4196 var ActivePosition = /*#__PURE__*/Object.freeze({ 4197 __proto__: null, 4198 exhibit: exhibit 4199 }); 4200 4201 var getDocument = function () { 4202 return SugarElement.fromDom(document); 4203 }; 4204 4205 var focus$1 = function (element) { 4206 return element.dom.focus(); 4207 }; 4208 var blur = function (element) { 4209 return element.dom.blur(); 4210 }; 4211 var hasFocus = function (element) { 4212 var root = getRootNode(element).dom; 4213 return element.dom === root.activeElement; 4214 }; 4215 var active = function (root) { 4216 if (root === void 0) { 4217 root = getDocument(); 4218 } 4219 return Optional.from(root.dom.activeElement).map(SugarElement.fromDom); 4220 }; 4221 var search = function (element) { 4222 return active(getRootNode(element)).filter(function (e) { 4223 return element.dom.contains(e.dom); 4224 }); 4225 }; 4226 4227 var preserve = function (f, container) { 4228 var dos = getRootNode(container); 4229 var refocus = active(dos).bind(function (focused) { 4230 var hasFocus = function (elem) { 4231 return eq$1(focused, elem); 4232 }; 4233 return hasFocus(container) ? Optional.some(container) : descendant(container, hasFocus); 4234 }); 4235 var result = f(container); 4236 refocus.each(function (oldFocus) { 4237 active(dos).filter(function (newFocus) { 4238 return eq$1(newFocus, oldFocus); 4239 }).fold(function () { 4240 focus$1(oldFocus); 4241 }, noop); 4242 }); 4243 return result; 4244 }; 4245 4246 var NuPositionCss = function (position, left, top, right, bottom) { 4247 return { 4248 position: position, 4249 left: left, 4250 top: top, 4251 right: right, 4252 bottom: bottom 4253 }; 4254 }; 4255 var applyPositionCss = function (element, position) { 4256 var addPx = function (num) { 4257 return num + 'px'; 4258 }; 4259 setOptions(element, { 4260 position: Optional.some(position.position), 4261 left: position.left.map(addPx), 4262 top: position.top.map(addPx), 4263 right: position.right.map(addPx), 4264 bottom: position.bottom.map(addPx) 4265 }); 4266 }; 4267 4268 var adt$3 = Adt.generate([ 4269 { none: [] }, 4270 { 4271 relative: [ 4272 'x', 4273 'y', 4274 'width', 4275 'height' 4276 ] 4277 }, 4278 { 4279 fixed: [ 4280 'x', 4281 'y', 4282 'width', 4283 'height' 4284 ] 4285 } 4286 ]); 4287 var positionWithDirection = function (posName, decision, x, y, width, height) { 4288 var decisionX = decision.x - x; 4289 var decisionY = decision.y - y; 4290 var decisionWidth = decision.width; 4291 var decisionHeight = decision.height; 4292 var decisionRight = width - (decisionX + decisionWidth); 4293 var decisionBottom = height - (decisionY + decisionHeight); 4294 var left = Optional.some(decisionX); 4295 var top = Optional.some(decisionY); 4296 var right = Optional.some(decisionRight); 4297 var bottom = Optional.some(decisionBottom); 4298 var none = Optional.none(); 4299 return cata(decision.direction, function () {
4300 return NuPositionCss(posName, left, top, none, none); 4301 }, function () { 4302 return NuPositionCss(posName, none, top, right, none); 4303 }, function () { 4304 return NuPositionCss(posName, left, none, none, bottom); 4305 }, function () { 4306 return NuPositionCss(posName, none, none, right, bottom); 4307 }, function () { 4308 return NuPositionCss(posName, left, top, none, none); 4309 }, function () { 4310 return NuPositionCss(posName, left, none, none, bottom); 4311 }, function () { 4312 return NuPositionCss(posName, left, top, none, none); 4313 }, function () { 4314 return NuPositionCss(posName, none, top, right, none); 4315 }); 4316 }; 4317 var reposition = function (origin, decision) { 4318 return origin.fold(function () { 4319 return NuPositionCss('absolute', Optional.some(decision.x), Optional.some(decision.y), Optional.none(), Optional.none()); 4320 }, function (x, y, width, height) { 4321 return positionWithDirection('absolute', decision, x, y, width, height); 4322 }, function (x, y, width, height) { 4323 return positionWithDirection('fixed', decision, x, y, width, height); 4324 }); 4325 }; 4326 var toBox = function (origin, element) { 4327 var rel = curry(find$3, element); 4328 var position = origin.fold(rel, rel, function () { 4329 var scroll = get$9(); 4330 return find$3(element).translate(-scroll.left, -scroll.top); 4331 }); 4332 var width = getOuter$2(element); 4333 var height = getOuter$1(element); 4334 return bounds$1(position.left, position.top, width, height); 4335 }; 4336 var viewport$1 = function (origin, getBounds) { 4337 return getBounds.fold(function () { 4338 return origin.fold(win, win, bounds$1); 4339 }, function (b) { 4340 return origin.fold(b, b, function () { 4341 var bounds = b(); 4342 var pos = translate(origin, bounds.x, bounds.y); 4343 return bounds$1(pos.left, pos.top, bounds.width, bounds.height); 4344 }); 4345 }); 4346 }; 4347 var translate = function (origin, x, y) { 4348 var pos = SugarPosition(x, y); 4349 var removeScroll = function () { 4350 var outerScroll = get$9(); 4351 return pos.translate(-outerScroll.left, -outerScroll.top); 4352 }; 4353 return origin.fold(constant(pos), constant(pos), removeScroll); 4354 }; 4355 var cata$1 = function (subject, onNone, onRelative, onFixed) { 4356 return subject.fold(onNone, onRelative, onFixed); 4357 }; 4358 var none$1 = adt$3.none; 4359 var relative = adt$3.relative; 4360 var fixed = adt$3.fixed; 4361 4362 var anchor = function (anchorBox, origin) { 4363 return { 4364 anchorBox: anchorBox, 4365 origin: origin 4366 }; 4367 }; 4368 var box$1 = function (anchorBox, origin) { 4369 return anchor(anchorBox, origin); 4370 }; 4371 4372 var cycleBy = function (value, delta, min, max) { 4373 var r = value + delta; 4374 if (r > max) { 4375 return min; 4376 } else if (r < min) { 4377 return max; 4378 } else { 4379 return r; 4380 } 4381 }; 4382 var clamp = function (value, min, max) { 4383 return Math.min(Math.max(value, min), max); 4384 }; 4385 4386 var adt$4 = Adt.generate([ 4387 { fit: ['reposition'] }, 4388 { 4389 nofit: [ 4390 'reposition', 4391 'deltaW', 4392 'deltaH' 4393 ] 4394 } 4395 ]); 4396 var calcReposition = function (newX, newY, width, height, bounds) { 4397 var boundsX = bounds.x; 4398 var boundsY = bounds.y; 4399 var boundsWidth = bounds.width; 4400 var boundsHeight = bounds.height; 4401 var xInBounds = newX >= boundsX; 4402 var yInBounds = newY >= boundsY; 4403 var originInBounds = xInBounds && yInBounds; 4404 var xFit = newX + width <= boundsX + boundsWidth; 4405 var yFit = newY + height <= boundsY + boundsHeight; 4406 var sizeInBounds = xFit && yFit; 4407 var deltaW = Math.abs(Math.min(width, xInBounds ? boundsX + boundsWidth - newX : boundsX - (newX + width))); 4408 var deltaH = Math.abs(Math.min(height, yInBounds ? boundsY + boundsHeight - newY : boundsY - (newY + height))); 4409 var maxX = Math.max(bounds.x, bounds.right - width); 4410 var maxY = Math.max(bounds.y, bounds.bottom - height); 4411 var limitX = clamp(newX, bounds.x, maxX); 4412 var limitY = clamp(newY, bounds.y, maxY); 4413 return { 4414 originInBounds: originInBounds, 4415 sizeInBounds: sizeInBounds, 4416 limitX: limitX, 4417 limitY: limitY, 4418 deltaW: deltaW, 4419 deltaH: deltaH 4420 }; 4421 }; 4422 var attempt = function (candidate, width, height, bounds) { 4423 var candidateX = candidate.x; 4424 var candidateY = candidate.y; 4425 var bubbleOffsets = candidate.bubble.offset; 4426 var bubbleLeft = bubbleOffsets.left; 4427 var bubbleTop = bubbleOffsets.top; 4428 var adjustedBounds = adjustBounds(bounds, candidate.boundsRestriction, bubbleOffsets); 4429 var boundsY = adjustedBounds.y; 4430 var boundsBottom = adjustedBounds.bottom; 4431 var boundsX = adjustedBounds.x; 4432 var boundsRight = adjustedBounds.right; 4433 var newX = candidateX + bubbleLeft; 4434 var newY = candidateY + bubbleTop; 4435 var _a = calcReposition(newX, newY, width, height, adjustedBounds), originInBounds = _a.originInBounds, sizeInBounds = _a.sizeInBounds, limitX = _a.limitX, limitY = _a.limitY, deltaW = _a.deltaW, deltaH = _a.deltaH; 4436 var upAvailable = constant(limitY + deltaH - boundsY); 4437 var downAvailable = constant(boundsBottom - limitY); 4438 var maxHeight = cataVertical(candidate.direction, downAvailable, downAvailable, upAvailable); 4439 var westAvailable = constant(limitX + deltaW - boundsX); 4440 var eastAvailable = constant(boundsRight - limitX); 4441 var maxWidth = cataHorizontal(candidate.direction, eastAvailable, eastAvailable, westAvailable); 4442 var reposition = { 4443 x: limitX, 4444 y: limitY, 4445 width: deltaW, 4446 height: deltaH, 4447 maxHeight: maxHeight, 4448 maxWidth: maxWidth, 4449 direction: candidate.direction, 4450 classes: { 4451 on: candidate.bubble.classesOn, 4452 off: candidate.bubble.classesOff 4453 }, 4454 label: candidate.label, 4455 candidateYforTest: newY 4456 }; 4457 return originInBounds && sizeInBounds ? adt$4.fit(reposition) : adt$4.nofit(reposition, deltaW, deltaH); 4458 }; 4459 var attempts = function (candidates, anchorBox, elementBox, bubbles, bounds) { 4460 var panelWidth = elementBox.width; 4461 var panelHeight = elementBox.height; 4462 var attemptBestFit = function (layout, reposition, deltaW, deltaH) { 4463 var next = layout(anchorBox, elementBox, bubbles); 4464 var attemptLayout = attempt(next, panelWidth, panelHeight, bounds); 4465 return attemptLayout.fold(adt$4.fit, function (newReposition, newDeltaW, newDeltaH) { 4466 var improved = newDeltaH > deltaH || newDeltaW > deltaW; 4467 return improved ? adt$4.nofit(newReposition, newDeltaW, newDeltaH) : adt$4.nofit(reposition, deltaW, deltaH); 4468 }); 4469 }; 4470 var abc = foldl(candidates, function (b, a) { 4471 var bestNext = curry(attemptBestFit, a); 4472 return b.fold(adt$4.fit, bestNext); 4473 }, adt$4.nofit({ 4474 x: anchorBox.x, 4475 y: anchorBox.y, 4476 width: elementBox.width, 4477 height: elementBox.height, 4478 maxHeight: elementBox.height, 4479 maxWidth: elementBox.width, 4480 direction: southeast(), 4481 classes: { 4482 on: [], 4483 off: [] 4484 }, 4485 label: 'none', 4486 candidateYforTest: anchorBox.y 4487 }, -1, -1)); 4488 return abc.fold(identity, identity); 4489 }; 4490 4491 var elementSize = function (p) { 4492 return { 4493 width: getOuter$2(p), 4494 height: getOuter$1(p) 4495 }; 4496 }; 4497 var layout = function (anchorBox, element, bubbles, options) { 4498 remove$6(element, 'max-height'); 4499 remove$6(element, 'max-width'); 4500 var elementBox = elementSize(element); 4501 return attempts(options.preference, anchorBox, elementBox, bubbles, options.bounds); 4502 }; 4503 var setClasses = function (element, decision) { 4504 var classInfo = decision.classes; 4505 remove$5(element, classInfo.off); 4506 add$3(element, classInfo.on); 4507 }; 4508 var setHeight = function (element, decision, options) { 4509 var maxHeightFunction = options.maxHeightFunction; 4510 maxHeightFunction(element, decision.maxHeight); 4511 };
4512 var setWidth = function (element, decision, options) { 4513 var maxWidthFunction = options.maxWidthFunction; 4514 maxWidthFunction(element, decision.maxWidth); 4515 }; 4516 var position = function (element, decision, options) { 4517 applyPositionCss(element, reposition(options.origin, decision)); 4518 }; 4519 4520 var setMaxHeight = function (element, maxHeight) { 4521 setMax(element, Math.floor(maxHeight)); 4522 }; 4523 var anchored = constant(function (element, available) { 4524 setMaxHeight(element, available); 4525 setAll$1(element, { 4526 'overflow-x': 'hidden', 4527 'overflow-y': 'auto' 4528 }); 4529 }); 4530 var expandable = constant(function (element, available) { 4531 setMaxHeight(element, available); 4532 }); 4533 4534 var defaultOr = function (options, key, dephault) { 4535 return options[key] === undefined ? dephault : options[key]; 4536 }; 4537 var simple = function (anchor, element, bubble, layouts, getBounds, overrideOptions) { 4538 var maxHeightFunction = defaultOr(overrideOptions, 'maxHeightFunction', anchored()); 4539 var maxWidthFunction = defaultOr(overrideOptions, 'maxWidthFunction', noop); 4540 var anchorBox = anchor.anchorBox; 4541 var origin = anchor.origin; 4542 var options = { 4543 bounds: viewport$1(origin, getBounds), 4544 origin: origin, 4545 preference: layouts, 4546 maxHeightFunction: maxHeightFunction, 4547 maxWidthFunction: maxWidthFunction 4548 }; 4549 go(anchorBox, element, bubble, options); 4550 }; 4551 var go = function (anchorBox, element, bubble, options) { 4552 var decision = layout(anchorBox, element, bubble, options); 4553 position(element, decision, options); 4554 setClasses(element, decision); 4555 setHeight(element, decision, options); 4556 setWidth(element, decision, options); 4557 }; 4558 4559 var allAlignments = [ 4560 'valignCentre', 4561 'alignLeft', 4562 'alignRight', 4563 'alignCentre', 4564 'top', 4565 'bottom', 4566 'left', 4567 'right' 4568 ]; 4569 var nu$8 = function (width, yoffset, classes) { 4570 var getClasses = function (prop) { 4571 return get$1(classes, prop).getOr([]); 4572 }; 4573 var make = function (xDelta, yDelta, alignmentsOn) { 4574 var alignmentsOff = difference(allAlignments, alignmentsOn); 4575 return { 4576 offset: SugarPosition(xDelta, yDelta), 4577 classesOn: bind(alignmentsOn, getClasses), 4578 classesOff: bind(alignmentsOff, getClasses) 4579 }; 4580 }; 4581 return { 4582 southeast: function () { 4583 return make(-width, yoffset, [ 4584 'top', 4585 'alignLeft' 4586 ]); 4587 }, 4588 southwest: function () { 4589 return make(width, yoffset, [ 4590 'top', 4591 'alignRight' 4592 ]); 4593 }, 4594 south: function () { 4595 return make(-width / 2, yoffset, [ 4596 'top', 4597 'alignCentre' 4598 ]); 4599 }, 4600 northeast: function () { 4601 return make(-width, -yoffset, [ 4602 'bottom', 4603 'alignLeft' 4604 ]); 4605 }, 4606 northwest: function () { 4607 return make(width, -yoffset, [ 4608 'bottom', 4609 'alignRight' 4610 ]); 4611 }, 4612 north: function () { 4613 return make(-width / 2, -yoffset, [ 4614 'bottom', 4615 'alignCentre' 4616 ]); 4617 }, 4618 east: function () { 4619 return make(width, -yoffset / 2, [ 4620 'valignCentre', 4621 'left' 4622 ]); 4623 }, 4624 west: function () { 4625 return make(-width, -yoffset / 2, [ 4626 'valignCentre', 4627 'right' 4628 ]); 4629 }, 4630 innerNorthwest: function () { 4631 return make(-width, yoffset, [ 4632 'top', 4633 'alignRight' 4634 ]); 4635 }, 4636 innerNortheast: function () { 4637 return make(width, yoffset, [ 4638 'top', 4639 'alignLeft' 4640 ]); 4641 }, 4642 innerNorth: function () { 4643 return make(-width / 2, yoffset, [ 4644 'top', 4645 'alignCentre' 4646 ]); 4647 }, 4648 innerSouthwest: function () { 4649 return make(-width, -yoffset, [ 4650 'bottom', 4651 'alignRight' 4652 ]); 4653 }, 4654 innerSoutheast: function () { 4655 return make(width, -yoffset, [ 4656 'bottom', 4657 'alignLeft' 4658 ]); 4659 }, 4660 innerSouth: function () { 4661 return make(-width / 2, -yoffset, [ 4662 'bottom', 4663 'alignCentre' 4664 ]); 4665 }, 4666 innerWest: function () { 4667 return make(width, -yoffset / 2, [ 4668 'valignCentre', 4669 'right' 4670 ]); 4671 }, 4672 innerEast: function () { 4673 return make(-width, -yoffset / 2, [ 4674 'valignCentre', 4675 'left' 4676 ]); 4677 } 4678 }; 4679 }; 4680 var fallback = function () { 4681 return nu$8(0, 0, {}); 4682 }; 4683 4684 var nu$9 = function (x) { 4685 return x; 4686 }; 4687 4688 var onDirection = function (isLtr, isRtl) { 4689 return function (element) { 4690 return getDirection(element) === 'rtl' ? isRtl : isLtr; 4691 }; 4692 }; 4693 var getDirection = function (element) { 4694 return get$5(element, 'direction') === 'rtl' ? 'rtl' : 'ltr'; 4695 }; 4696 4697 var AttributeValue; 4698 (function (AttributeValue) { 4699 AttributeValue['TopToBottom'] = 'toptobottom'; 4700 AttributeValue['BottomToTop'] = 'bottomtotop'; 4701 }(AttributeValue || (AttributeValue = {}))); 4702 var Attribute = 'data-alloy-vertical-dir'; 4703 var isBottomToTopDir = function (el) { 4704 return closest$2(el, function (current) { 4705 return isElement(current) && get$3(current, 'data-alloy-vertical-dir') === AttributeValue.BottomToTop; 4706 }); 4707 }; 4708 4709 var schema$1 = function () { 4710 return optionObjOf('layouts', [
4711 strict$1('onLtr'), 4712 strict$1('onRtl'), 4713 option('onBottomLtr'), 4714 option('onBottomRtl') 4715 ]); 4716 }; 4717 var get$b = function (elem, info, defaultLtr, defaultRtl, defaultBottomLtr, defaultBottomRtl, dirElement) { 4718 var isBottomToTop = dirElement.map(isBottomToTopDir).getOr(false); 4719 var customLtr = info.layouts.map(function (ls) { 4720 return ls.onLtr(elem); 4721 }); 4722 var customRtl = info.layouts.map(function (ls) { 4723 return ls.onRtl(elem); 4724 }); 4725 var ltr = isBottomToTop ? info.layouts.bind(function (ls) { 4726 return ls.onBottomLtr.map(function (f) { 4727 return f(elem); 4728 }); 4729 }).or(customLtr).getOr(defaultBottomLtr) : customLtr.getOr(defaultLtr); 4730 var rtl = isBottomToTop ? info.layouts.bind(function (ls) { 4731 return ls.onBottomRtl.map(function (f) { 4732 return f(elem); 4733 }); 4734 }).or(customRtl).getOr(defaultBottomRtl) : customRtl.getOr(defaultRtl); 4735 var f = onDirection(ltr, rtl); 4736 return f(elem); 4737 }; 4738 4739 var placement = function (component, anchorInfo, origin) { 4740 var hotspot = anchorInfo.hotspot; 4741 var anchorBox = toBox(origin, hotspot.element); 4742 var layouts = get$b(component.element, anchorInfo, belowOrAbove(), belowOrAboveRtl(), aboveOrBelow(), aboveOrBelowRtl(), Optional.some(anchorInfo.hotspot.element)); 4743 return Optional.some(nu$9({ 4744 anchorBox: anchorBox, 4745 bubble: anchorInfo.bubble.getOr(fallback()), 4746 overrides: anchorInfo.overrides, 4747 layouts: layouts, 4748 placer: Optional.none() 4749 })); 4750 }; 4751 var HotspotAnchor = [ 4752 strict$1('hotspot'), 4753 option('bubble'), 4754 defaulted$1('overrides', {}), 4755 schema$1(), 4756 output('placement', placement) 4757 ]; 4758 4759 var placement$1 = function (component, anchorInfo, origin) { 4760 var pos = translate(origin, anchorInfo.x, anchorInfo.y); 4761 var anchorBox = bounds$1(pos.left, pos.top, anchorInfo.width, anchorInfo.height); 4762 var layouts = get$b(component.element, anchorInfo, all$2(), allRtl(), all$2(), allRtl(), Optional.none()); 4763 return Optional.some(nu$9({ 4764 anchorBox: anchorBox, 4765 bubble: anchorInfo.bubble, 4766 overrides: anchorInfo.overrides, 4767 layouts: layouts, 4768 placer: Optional.none() 4769 })); 4770 }; 4771 var MakeshiftAnchor = [ 4772 strict$1('x'), 4773 strict$1('y'), 4774 defaulted$1('height', 0), 4775 defaulted$1('width', 0), 4776 defaulted$1('bubble', fallback()), 4777 defaulted$1('overrides', {}), 4778 schema$1(), 4779 output('placement', placement$1) 4780 ]; 4781 4782 var adt$5 = Adt.generate([ 4783 { screen: ['point'] }, 4784 { 4785 absolute: [ 4786 'point', 4787 'scrollLeft', 4788 'scrollTop' 4789 ] 4790 } 4791 ]); 4792 var toFixed = function (pos) { 4793 return pos.fold(identity, function (point, scrollLeft, scrollTop) { 4794 return point.translate(-scrollLeft, -scrollTop); 4795 }); 4796 }; 4797 var toAbsolute = function (pos) { 4798 return pos.fold(identity, identity); 4799 }; 4800 var sum = function (points) { 4801 return foldl(points, function (b, a) { 4802 return b.translate(a.left, a.top); 4803 }, SugarPosition(0, 0)); 4804 }; 4805 var sumAsFixed = function (positions) { 4806 var points = map(positions, toFixed); 4807 return sum(points); 4808 }; 4809 var sumAsAbsolute = function (positions) { 4810 var points = map(positions, toAbsolute); 4811 return sum(points); 4812 }; 4813 var screen = adt$5.screen; 4814 var absolute$2 = adt$5.absolute; 4815 4816 var getOffset = function (component, origin, anchorInfo) { 4817 var win = defaultView(anchorInfo.root).dom; 4818 var hasSameOwner = function (frame) { 4819 var frameOwner = owner(frame); 4820 var compOwner = owner(component.element); 4821 return eq$1(frameOwner, compOwner); 4822 }; 4823 return Optional.from(win.frameElement).map(SugarElement.fromDom).filter(hasSameOwner).map(absolute); 4824 }; 4825 var getRootPoint = function (component, origin, anchorInfo) { 4826 var doc = owner(component.element); 4827 var outerScroll = get$9(doc); 4828 var offset = getOffset(component, origin, anchorInfo).getOr(outerScroll); 4829 return absolute$2(offset, outerScroll.left, outerScroll.top); 4830 }; 4831 4832 var capRect = function (left, top, width, height) { 4833 var newLeft = left, newTop = top, newWidth = width, newHeight = height; 4834 if (left < 0) { 4835 newLeft = 0; 4836 newWidth = width + left; 4837 } 4838 if (top < 0) { 4839 newTop = 0; 4840 newHeight = height + top; 4841 } 4842 var point = screen(SugarPosition(newLeft, newTop)); 4843 return Optional.some(pointed(point, newWidth, newHeight)); 4844 }; 4845 var calcNewAnchor = function (optBox, rootPoint, anchorInfo, origin, elem) { 4846 return optBox.map(function (box) { 4847 var points = [ 4848 rootPoint, 4849 box.point 4850 ]; 4851 var topLeft = cata$1(origin, function () { 4852 return sumAsAbsolute(points); 4853 }, function () { 4854 return sumAsAbsolute(points); 4855 }, function () { 4856 return sumAsFixed(points); 4857 }); 4858 var anchorBox = rect(topLeft.left, topLeft.top, box.width, box.height); 4859 var layoutsLtr = anchorInfo.showAbove ? aboveOrBelow() : belowOrAbove(); 4860 var layoutsRtl = anchorInfo.showAbove ? aboveOrBelowRtl() : belowOrAboveRtl(); 4861 var layouts = get$b(elem, anchorInfo, layoutsLtr, layoutsRtl, layoutsLtr, layoutsRtl, Optional.none()); 4862 return nu$9({ 4863 anchorBox: anchorBox, 4864 bubble: anchorInfo.bubble.getOr(fallback()), 4865 overrides: anchorInfo.overrides, 4866 layouts: layouts, 4867 placer: Optional.none() 4868 }); 4869 }); 4870 }; 4871
4872 var placement$2 = function (component, anchorInfo, origin) { 4873 var rootPoint = getRootPoint(component, origin, anchorInfo); 4874 return anchorInfo.node.filter(inBody).bind(function (target) { 4875 var rect = target.dom.getBoundingClientRect(); 4876 var nodeBox = capRect(rect.left, rect.top, rect.width, rect.height); 4877 var elem = anchorInfo.node.getOr(component.element); 4878 return calcNewAnchor(nodeBox, rootPoint, anchorInfo, origin, elem); 4879 }); 4880 }; 4881 var NodeAnchor = [ 4882 strict$1('node'), 4883 strict$1('root'), 4884 option('bubble'), 4885 schema$1(), 4886 defaulted$1('overrides', {}), 4887 defaulted$1('showAbove', false), 4888 output('placement', placement$2) 4889 ]; 4890 4891 var zeroWidth = '\uFEFF'; 4892 var nbsp = '\xA0'; 4893 4894 var create$2 = function (start, soffset, finish, foffset) { 4895 return { 4896 start: start, 4897 soffset: soffset, 4898 finish: finish, 4899 foffset: foffset 4900 }; 4901 }; 4902 var SimRange = { create: create$2 }; 4903 4904 var adt$6 = Adt.generate([ 4905 { before: ['element'] }, 4906 { 4907 on: [ 4908 'element', 4909 'offset' 4910 ] 4911 }, 4912 { after: ['element'] } 4913 ]); 4914 var cata$2 = function (subject, onBefore, onOn, onAfter) { 4915 return subject.fold(onBefore, onOn, onAfter); 4916 }; 4917 var getStart = function (situ) { 4918 return situ.fold(identity, identity, identity); 4919 }; 4920 var before$2 = adt$6.before; 4921 var on = adt$6.on; 4922 var after$1 = adt$6.after; 4923 var Situ = { 4924 before: before$2, 4925 on: on, 4926 after: after$1, 4927 cata: cata$2, 4928 getStart: getStart 4929 }; 4930 4931 var adt$7 = Adt.generate([ 4932 { domRange: ['rng'] }, 4933 { 4934 relative: [ 4935 'startSitu', 4936 'finishSitu' 4937 ] 4938 }, 4939 { 4940 exact: [ 4941 'start', 4942 'soffset', 4943 'finish', 4944 'foffset' 4945 ] 4946 } 4947 ]); 4948 var exactFromRange = function (simRange) { 4949 return adt$7.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset); 4950 }; 4951 var getStart$1 = function (selection) { 4952 return selection.match({ 4953 domRange: function (rng) { 4954 return SugarElement.fromDom(rng.startContainer); 4955 }, 4956 relative: function (startSitu, _finishSitu) { 4957 return Situ.getStart(startSitu); 4958 }, 4959 exact: function (start, _soffset, _finish, _foffset) { 4960 return start; 4961 } 4962 }); 4963 }; 4964 var domRange = adt$7.domRange; 4965 var relative$1 = adt$7.relative; 4966 var exact = adt$7.exact; 4967 var getWin = function (selection) { 4968 var start = getStart$1(selection); 4969 return defaultView(start); 4970 }; 4971 var range$1 = SimRange.create; 4972 var SimSelection = { 4973 domRange: domRange, 4974 relative: relative$1, 4975 exact: exact, 4976 exactFromRange: exactFromRange, 4977 getWin: getWin, 4978 range: range$1 4979 }; 4980 4981 var setStart = function (rng, situ) { 4982 situ.fold(function (e) { 4983 rng.setStartBefore(e.dom); 4984 }, function (e, o) { 4985 rng.setStart(e.dom, o); 4986 }, function (e) { 4987 rng.setStartAfter(e.dom); 4988 }); 4989 }; 4990 var setFinish = function (rng, situ) { 4991 situ.fold(function (e) { 4992 rng.setEndBefore(e.dom); 4993 }, function (e, o) { 4994 rng.setEnd(e.dom, o); 4995 }, function (e) { 4996 rng.setEndAfter(e.dom); 4997 }); 4998 }; 4999 var relativeToNative = function (win, startSitu, finishSitu) { 5000 var range = win.document.createRange(); 5001 setStart(range, startSitu); 5002 setFinish(range, finishSitu); 5003 return range; 5004 }; 5005 var exactToNative = function (win, start, soffset, finish, foffset) { 5006 var rng = win.document.createRange(); 5007 rng.setStart(start.dom, soffset); 5008 rng.setEnd(finish.dom, foffset); 5009 return rng; 5010 }; 5011 var toRect = function (rect) { 5012 return { 5013 left: rect.left, 5014 top: rect.top, 5015 right: rect.right, 5016 bottom: rect.bottom, 5017 width: rect.width, 5018 height: rect.height 5019 }; 5020 }; 5021 var getFirstRect = function (rng) { 5022 var rects = rng.getClientRects(); 5023 var rect = rects.length > 0 ? rects[0] : rng.getBoundingClientRect(); 5024 return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect) : Optional.none(); 5025 }; 5026 5027 var adt$8 = Adt.generate([ 5028 { 5029 ltr: [ 5030 'start', 5031 'soffset', 5032 'finish', 5033 'foffset' 5034 ] 5035 }, 5036 { 5037 rtl: [ 5038 'start', 5039 'soffset', 5040 'finish', 5041 'foffset' 5042 ] 5043 } 5044 ]); 5045 var fromRange = function (win, type, range) { 5046 return type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset); 5047 }; 5048 var getRanges = function (win, selection) { 5049 return selection.match({ 5050 domRange: function (rng) { 5051 return { 5052 ltr: constant(rng), 5053 rtl: Optional.none 5054 }; 5055 }, 5056 relative: function (startSitu, finishSitu) { 5057 return { 5058 ltr: cached(function () { 5059 return relativeToNative(win, startSitu, finishSitu); 5060 }), 5061 rtl: cached(function () { 5062 return Optional.some(relativeToNative(win, finishSitu, startSitu)); 5063 }) 5064 }; 5065 }, 5066 exact: function (start, soffset, finish, foffset) { 5067 return { 5068 ltr: cached(function () { 5069 return exactToNative(win, start, soffset, finish, foffset); 5070 }), 5071 rtl: cached(function () { 5072 return Optional.some(exactToNative(win, finish, foffset, start, soffset)); 5073 }) 5074 }; 5075 } 5076 }); 5077 }; 5078 var doDiagnose = function (win, ranges) { 5079 var rng = ranges.ltr(); 5080 if (rng.collapsed) { 5081 var reversed = ranges.rtl().filter(function (rev) { 5082 return rev.collapsed === false; 5083 }); 5084 return reversed.map(function (rev) { 5085 return adt$8.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset); 5086 }).getOrThunk(function () { 5087 return fromRange(win, adt$8.ltr, rng); 5088 }); 5089 } else { 5090 return fromRange(win, adt$8.ltr, rng); 5091 } 5092 }; 5093 var diagnose = function (win, selection) { 5094 var ranges = getRanges(win, selection); 5095 return doDiagnose(win, ranges); 5096 }; 5097 var asLtrRange = function (win, selection) { 5098 var diagnosis = diagnose(win, selection); 5099 return diagnosis.match({ 5100 ltr: function (start, soffset, finish, foffset) { 5101 var rng = win.document.createRange(); 5102 rng.setStart(start.dom, soffset); 5103 rng.setEnd(finish.dom, foffset); 5104 return rng; 5105 }, 5106 rtl: function (start, soffset, finish, foffset) { 5107 var rng = win.document.createRange(); 5108 rng.setStart(finish.dom, foffset); 5109 rng.setEnd(start.dom, soffset); 5110 return rng; 5111 } 5112 }); 5113 }; 5114 var ltr = adt$8.ltr; 5115 var rtl = adt$8.rtl; 5116 5117 var NodeValue = function (is, name) { 5118 var get = function (element) { 5119 if (!is(element)) { 5120 throw new Error('Can only get ' + name + ' value of a ' + n
5120ame + ' node'); 5121 } 5122 return getOption(element).getOr(''); 5123 }; 5124 var getOption = function (element) { 5125 return is(element) ? Optional.from(element.dom.nodeValue) : Optional.none(); 5126 }; 5127 var set = function (element, value) { 5128 if (!is(element)) { 5129 throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node'); 5130 } 5131 element.dom.nodeValue = value; 5132 }; 5133 return { 5134 get: get, 5135 getOption: getOption, 5136 set: set 5137 }; 5138 }; 5139 5140 var api$2 = NodeValue(isText, 'text'); 5141 var get$c = function (element) { 5142 return api$2.get(element); 5143 }; 5144 var getOption = function (element) { 5145 return api$2.getOption(element); 5146 }; 5147 5148 var getEnd = function (element) { 5149 return name(element) === 'img' ? 1 : getOption(element).fold(function () { 5150 return children(element).length; 5151 }, function (v) { 5152 return v.length; 5153 }); 5154 }; 5155 var isTextNodeWithCursorPosition = function (el) { 5156 return getOption(el).filter(function (text) { 5157 return text.trim().length !== 0 || text.indexOf(nbsp) > -1; 5158 }).isSome(); 5159 }; 5160 var elementsWithCursorPosition = [ 5161 'img', 5162 'br' 5163 ]; 5164 var isCursorPosition = function (elem) { 5165 var hasCursorPosition = isTextNodeWithCursorPosition(elem); 5166 return hasCursorPosition || contains(elementsWithCursorPosition, name(elem)); 5167 }; 5168 5169 var last$1 = function (element) { 5170 return descendantRtl(element, isCursorPosition); 5171 }; 5172 var descendantRtl = function (scope, predicate) { 5173 var descend = function (element) { 5174 var children$1 = children(element); 5175 for (var i = children$1.length - 1; i >= 0; i--) { 5176 var child = children$1[i]; 5177 if (predicate(child)) { 5178 return Optional.some(child); 5179 } 5180 var res = descend(child); 5181 if (res.isSome()) { 5182 return res; 5183 } 5184 } 5185 return Optional.none(); 5186 }; 5187 return descend(scope); 5188 }; 5189 5190 var descendants = function (scope, selector) { 5191 return all(selector, scope); 5192 }; 5193 5194 var makeRange = function (start, soffset, finish, foffset) { 5195 var doc = owner(start); 5196 var rng = doc.dom.createRange(); 5197 rng.setStart(start.dom, soffset); 5198 rng.setEnd(finish.dom, foffset); 5199 return rng; 5200 }; 5201 var after$2 = function (start, soffset, finish, foffset) { 5202 var r = makeRange(start, soffset, finish, foffset); 5203 var same = eq$1(start, finish) && soffset === foffset; 5204 return r.collapsed && !same; 5205 }; 5206 5207 var getNativeSelection = function (win) { 5208 return Optional.from(win.getSelection()); 5209 }; 5210 var readRange = function (selection) { 5211 if (selection.rangeCount > 0) { 5212 var firstRng = selection.getRangeAt(0); 5213 var lastRng = selection.getRangeAt(selection.rangeCount - 1); 5214 return Optional.some(SimRange.create(SugarElement.fromDom(firstRng.startContainer), firstRng.startOffset, SugarElement.fromDom(lastRng.endContainer), lastRng.endOffset)); 5215 } else { 5216 return Optional.none(); 5217 } 5218 }; 5219 var doGetExact = function (selection) { 5220 if (selection.anchorNode === null || selection.focusNode === null) { 5221 return readRange(selection); 5222 } else { 5223 var anchor = SugarElement.fromDom(selection.anchorNode); 5224 var focus_1 = SugarElement.fromDom(selection.focusNode); 5225 return after$2(anchor, selection.anchorOffset, focus_1, selection.focusOffset) ? Optional.some(SimRange.create(anchor, selection.anchorOffset, focus_1, selection.focusOffset)) : readRange(selection); 5226 } 5227 }; 5228 var getExact = function (win) { 5229 return getNativeSelection(win).filter(function (sel) { 5230 return sel.rangeCount > 0; 5231 }).bind(doGetExact); 5232 }; 5233 var getFirstRect$1 = function (win, selection) { 5234 var rng = asLtrRange(win, selection); 5235 return getFirstRect(rng); 5236 }; 5237 5238 var point = function (element, offset) { 5239 return { 5240 element: element, 5241 offset: offset 5242 }; 5243 }; 5244 var descendOnce = function (element, offset) { 5245 var children$1 = children(element); 5246 if (children$1.length === 0) { 5247 return point(element, offset); 5248 } else if (offset < children$1.length) { 5249 return point(children$1[offset], 0); 5250 } else { 5251 var last = children$1[children$1.length - 1]; 5252 var len = isText(last) ? get$c(last).length : children(last).length; 5253 return point(last, len); 5254 } 5255 }; 5256 5257 var descendOnce$1 = function (element, offset) { 5258 return isText(element) ? point(element, offset) : descendOnce(element, offset); 5259 }; 5260 var getAnchorSelection = function (win, anchorInfo) { 5261 var getSelection = anchorInfo.getSelection.getOrThunk(function () { 5262 return function () { 5263 return getExact(win); 5264 }; 5265 }); 5266 return getSelection().map(function (sel) {
5267 var modStart = descendOnce$1(sel.start, sel.soffset); 5268 var modFinish = descendOnce$1(sel.finish, sel.foffset); 5269 return SimSelection.range(modStart.element, modStart.offset, modFinish.element, modFinish.offset); 5270 }); 5271 }; 5272 var placement$3 = function (component, anchorInfo, origin) { 5273 var win = defaultView(anchorInfo.root).dom; 5274 var rootPoint = getRootPoint(component, origin, anchorInfo); 5275 var selectionBox = getAnchorSelection(win, anchorInfo).bind(function (sel) { 5276 var optRect = getFirstRect$1(win, SimSelection.exactFromRange(sel)).orThunk(function () { 5277 var x = SugarElement.fromText(zeroWidth); 5278 before(sel.start, x); 5279 return getFirstRect$1(win, SimSelection.exact(x, 0, x, 1)).map(function (rect) { 5280 remove(x); 5281 return rect; 5282 }); 5283 }); 5284 return optRect.bind(function (rawRect) { 5285 return capRect(rawRect.left, rawRect.top, rawRect.width, rawRect.height); 5286 }); 5287 }); 5288 var targetElement = getAnchorSelection(win, anchorInfo).bind(function (sel) { 5289 return isElement(sel.start) ? Optional.some(sel.start) : parentNode(sel.start); 5290 }); 5291 var elem = targetElement.getOr(component.element); 5292 return calcNewAnchor(selectionBox, rootPoint, anchorInfo, origin, elem); 5293 }; 5294 var SelectionAnchor = [ 5295 option('getSelection'), 5296 strict$1('root'), 5297 option('bubble'), 5298 schema$1(), 5299 defaulted$1('overrides', {}), 5300 defaulted$1('showAbove', false), 5301 output('placement', placement$3) 5302 ]; 5303 5304 var eastX$1 = function (anchor) { 5305 return anchor.x + anchor.width; 5306 }; 5307 var westX$1 = function (anchor, element) { 5308 return anchor.x - element.width; 5309 }; 5310 var northY$1 = function (anchor, element) { 5311 return anchor.y - element.height + anchor.height; 5312 }; 5313 var southY$1 = function (anchor) { 5314 return anchor.y; 5315 }; 5316 var southeast$2 = function (anchor, element, bubbles) { 5317 return nu$7(eastX$1(anchor), southY$1(anchor), bubbles.southeast(), southeast(), boundsRestriction(anchor, { 5318 left: 0, 5319 top: 2 5320 }), 'link-layout-se'); 5321 }; 5322 var southwest$2 = function (anchor, element, bubbles) { 5323 return nu$7(westX$1(anchor, element), southY$1(anchor), bubbles.southwest(), southwest(), boundsRestriction(anchor, { 5324 right: 1, 5325 top: 2 5326 }), 'link-layout-sw'); 5327 }; 5328 var northeast$2 = function (anchor, element, bubbles) { 5329 return nu$7(eastX$1(anchor), northY$1(anchor, element), bubbles.northeast(), northeast(), boundsRestriction(anchor, { 5330 left: 0, 5331 bottom: 3 5332 }), 'link-layout-ne'); 5333 }; 5334 var northwest$2 = function (anchor, element, bubbles) { 5335 return nu$7(westX$1(anchor, element), northY$1(anchor, element), bubbles.northwest(), northwest(), boundsRestriction(anchor, { 5336 right: 1, 5337 bottom: 3 5338 }), 'link-layout-nw'); 5339 }; 5340 var all$3 = function () { 5341 return [ 5342 southeast$2, 5343 southwest$2, 5344 northeast$2, 5345 northwest$2 5346 ]; 5347 }; 5348 var allRtl$1 = function () { 5349 return [ 5350 southwest$2, 5351 southeast$2, 5352 northwest$2, 5353 northeast$2 5354 ]; 5355 }; 5356 5357 var placement$4 = function (component, submenuInfo, origin) { 5358 var anchorBox = toBox(origin, submenuInfo.item.element); 5359 var layouts = get$b(component.element, submenuInfo, all$3(), allRtl$1(), all$3(), allRtl$1(), Optional.none()); 5360 return Optional.some(nu$9({ 5361 anchorBox: anchorBox, 5362 bubble: fallback(), 5363 overrides: submenuInfo.overrides, 5364 layouts: layouts, 5365 placer: Optional.none() 5366 })); 5367 }; 5368 var SubmenuAnchor = [ 5369 strict$1('item'), 5370 schema$1(), 5371 defaulted$1('overrides', {}), 5372 output('placement', placement$4) 5373 ]; 5374 5375 var AnchorSchema = choose$1('anchor', { 5376 selection: SelectionAnchor, 5377 node: NodeAnchor, 5378 hotspot: HotspotAnchor, 5379 submenu: SubmenuAnchor, 5380 makeshift: MakeshiftAnchor 5381 }); 5382 5383 var getFixedOrigin = function () { 5384 var html = document.documentElement; 5385 return fixed(0, 0, html.clientWidth, html.clientHeight); 5386 }; 5387 var getRelativeOrigin = function (component) { 5388 var position = absolute(component.element); 5389 var bounds = component.element.dom.getBoundingClientRect(); 5390 return relative(position.left, position.top, bounds.width, bounds.height); 5391 }; 5392 var place = function (component, origin, anchoring, getBounds, placee) { 5393 var anchor = box$1(anchoring.anchorBox, origin);
5394 simple(anchor, placee.element, anchoring.bubble, anchoring.layouts, getBounds, anchoring.overrides); 5395 }; 5396 var position$1 = function (component, posConfig, posState, anchor, placee) { 5397 positionWithin(component, posConfig, posState, anchor, placee, Optional.none()); 5398 }; 5399 var positionWithin = function (component, posConfig, posState, anchor, placee, boxElement) { 5400 var boundsBox = boxElement.map(box); 5401 return positionWithinBounds(component, posConfig, posState, anchor, placee, boundsBox); 5402 }; 5403 var positionWithinBounds = function (component, posConfig, posState, anchor, placee, bounds) { 5404 var anchorage = asRawOrDie('positioning anchor.info', AnchorSchema, anchor); 5405 preserve(function () { 5406 set$2(placee.element, 'position', 'fixed'); 5407 var oldVisibility = getRaw(placee.element, 'visibility'); 5408 set$2(placee.element, 'visibility', 'hidden'); 5409 var origin = posConfig.useFixed() ? getFixedOrigin() : getRelativeOrigin(component); 5410 var placer = anchorage.placement; 5411 var getBounds = bounds.map(constant).or(posConfig.getBounds); 5412 placer(component, anchorage, origin).each(function (anchoring) { 5413 var doPlace = anchoring.placer.getOr(place); 5414 doPlace(component, origin, anchoring, getBounds, placee); 5415 }); 5416 oldVisibility.fold(function () { 5417 remove$6(placee.element, 'visibility'); 5418 }, function (vis) { 5419 set$2(placee.element, 'visibility', vis); 5420 }); 5421 if (getRaw(placee.element, 'left').isNone() && getRaw(placee.element, 'top').isNone() && getRaw(placee.element, 'right').isNone() && getRaw(placee.element, 'bottom').isNone() && getRaw(placee.element, 'position').is('fixed')) { 5422 remove$6(placee.element, 'position'); 5423 } 5424 }, placee.element); 5425 }; 5426 var getMode = function (component, pConfig, _pState) { 5427 return pConfig.useFixed() ? 'fixed' : 'absolute'; 5428 }; 5429 5430 var PositionApis = /*#__PURE__*/Object.freeze({ 5431 __proto__: null, 5432 position: position$1, 5433 positionWithin: positionWithin, 5434 positionWithinBounds: positionWithinBounds, 5435 getMode: getMode 5436 }); 5437 5438 var PositionSchema = [ 5439 defaulted$1('useFixed', never), 5440 option('getBounds') 5441 ]; 5442 5443 var Positioning = create$1({ 5444 fields: PositionSchema, 5445 name: 'positioning', 5446 active: ActivePosition, 5447 apis: PositionApis 5448 }); 5449 5450 var fireDetaching = function (component) { 5451 emit(component, detachedFromDom()); 5452 var children = component.components(); 5453 each(children, fireDetaching); 5454 }; 5455 var fireAttaching = function (component) { 5456 var children = component.components(); 5457 each(children, fireAttaching); 5458 emit(component, attachedToDom()); 5459 }; 5460 var attach = function (parent, child) { 5461 append(parent.element, child.element); 5462 }; 5463 var detachChildren = function (component) { 5464 each(component.components(), function (childComp) { 5465 return remove(childComp.element); 5466 }); 5467 empty(component.element); 5468 component.syncComponents(); 5469 }; 5470 var replaceChildren = function (component, newChildren) { 5471 var subs = component.components(); 5472 detachChildren(component); 5473 var deleted = difference(subs, newChildren); 5474 each(deleted, function (comp) { 5475 fireDetaching(comp); 5476 component.getSystem().removeFromWorld(comp); 5477 }); 5478 each(newChildren, function (childComp) { 5479 if (!childComp.getSystem().isConnected()) { 5480 component.getSystem().addToWorld(childComp); 5481 attach(component, childComp); 5482 if (inBody(component.element)) { 5483 fireAttaching(childComp); 5484 } 5485 } else { 5486 attach(component, childComp); 5487 } 5488 component.syncComponents(); 5489 }); 5490 }; 5491 5492 var attach$1 = function (parent, child) { 5493 attachWith(parent, child, append); 5494 }; 5495 var attachWith = function (parent, child, insertion) { 5496 parent.getSystem().addToWorld(child); 5497 insertion(parent.element, child.element);
5498 if (inBody(parent.element)) { 5499 fireAttaching(child); 5500 } 5501 parent.syncComponents(); 5502 }; 5503 var doDetach = function (component) { 5504 fireDetaching(component); 5505 remove(component.element); 5506 component.getSystem().removeFromWorld(component); 5507 }; 5508 var detach = function (component) { 5509 var parent$1 = parent(component.element).bind(function (p) { 5510 return component.getSystem().getByDom(p).toOptional(); 5511 }); 5512 doDetach(component); 5513 parent$1.each(function (p) { 5514 p.syncComponents(); 5515 }); 5516 }; 5517 var detachChildren$1 = function (component) { 5518 var subs = component.components(); 5519 each(subs, doDetach); 5520 empty(component.element); 5521 component.syncComponents(); 5522 }; 5523 var attachSystem = function (element, guiSystem) { 5524 attachSystemWith(element, guiSystem, append); 5525 }; 5526 var attachSystemAfter = function (element, guiSystem) { 5527 attachSystemWith(element, guiSystem, after); 5528 }; 5529 var attachSystemWith = function (element, guiSystem, inserter) { 5530 inserter(element, guiSystem.element); 5531 var children$1 = children(guiSystem.element); 5532 each(children$1, function (child) { 5533 guiSystem.getByDom(child).each(fireAttaching); 5534 }); 5535 }; 5536 var detachSystem = function (guiSystem) { 5537 var children$1 = children(guiSystem.element); 5538 each(children$1, function (child) { 5539 guiSystem.getByDom(child).each(fireDetaching); 5540 }); 5541 remove(guiSystem.element); 5542 }; 5543 5544 var rebuild = function (sandbox, sConfig, sState, data) { 5545 sState.get().each(function (_data) { 5546 detachChildren$1(sandbox); 5547 }); 5548 var point = sConfig.getAttachPoint(sandbox); 5549 attach$1(point, sandbox); 5550 var built = sandbox.getSystem().build(data); 5551 attach$1(sandbox, built); 5552 sState.set(built); 5553 return built; 5554 }; 5555 var open = function (sandbox, sConfig, sState, data) { 5556 var newState = rebuild(sandbox, sConfig, sState, data); 5557 sConfig.onOpen(sandbox, newState); 5558 return newState; 5559 }; 5560 var setContent = function (sandbox, sConfig, sState, data) { 5561 return sState.get().map(function () { 5562 return rebuild(sandbox, sConfig, sState, data); 5563 }); 5564 }; 5565 var openWhileCloaked = function (sandbox, sConfig, sState, data, transaction) { 5566 cloak(sandbox, sConfig); 5567 open(sandbox, sConfig, sState, data); 5568 transaction(); 5569 decloak(sandbox, sConfig); 5570 }; 5571 var close = function (sandbox, sConfig, sState) { 5572 sState.get().each(function (data) { 5573 detachChildren$1(sandbox); 5574 detach(sandbox); 5575 sConfig.onClose(sandbox, data); 5576 sState.clear(); 5577 }); 5578 }; 5579 var isOpen = function (_sandbox, _sConfig, sState) { 5580 return sState.isOpen(); 5581 }; 5582 var isPartOf$1 = function (sandbox, sConfig, sState, queryElem) { 5583 return isOpen(sandbox, sConfig, sState) && sState.get().exists(function (data) { 5584 return sConfig.isPartOf(sandbox, data, queryElem); 5585 }); 5586 }; 5587 var getState = function (_sandbox, _sConfig, sState) { 5588 return sState.get(); 5589 }; 5590 var store = function (sandbox, cssKey, attr, newValue) { 5591 getRaw(sandbox.element, cssKey).fold(function () { 5592 remove$1(sandbox.element, attr); 5593 }, function (v) { 5594 set$1(sandbox.element, attr, v); 5595 }); 5596 set$2(sandbox.element, cssKey, newValue); 5597 }; 5598 var restore = function (sandbox, cssKey, attr) { 5599 getOpt(sandbox.element, attr).fold(function () { 5600 return remove$6(sandbox.element, cssKey); 5601 }, function (oldValue) { 5602 return set$2(sandbox.element, cssKey, oldValue); 5603 }); 5604 }; 5605 var cloak = function (sandbox, sConfig, _sState) { 5606 var sink = sConfig.getAttachPoint(sandbox); 5607 set$2(sandbox.element, 'position', Positioning.getMode(sink)); 5608 store(sandbox, 'visibility', sConfig.cloakVisibilityAttr, 'hidden'); 5609 }; 5610 var hasPosition = function (element) { 5611 return exists([ 5612 'top', 5613 'left', 5614 'right', 5615 'bottom' 5616 ], function (pos) { 5617 return getRaw(element, pos).isSome(); 5618 }); 5619 }; 5620 var decloak = function (sandbox, sConfig, _sState) { 5621 if (!hasPosition(sandbox.element)) { 5622 remove$6(sandbox.element, 'position'); 5623 } 5624 restore(sandbox, 'visibility', sConfig.cloakVisibilityAttr); 5625 }; 5626 5627 var SandboxApis = /*#__PURE__*/Object.freeze({ 5628 __proto__: null, 5629 cloak: cloak, 5630 decloak: decloak, 5631 open: open, 5632 openWhileCloaked: openWhileCloaked, 5633 close: close, 5634 isOpen: isOpen, 5635 isPartOf: isPartOf$1, 5636 getState: getState, 5637 setContent: setContent 5638 }); 5639 5640 var events$2 = function (sandboxConfig, sandboxState) { 5641 return derive([run(sandboxClose(), function (sandbox, _simulatedEvent) { 5642 close(sandbox, sandboxConfig, sandboxState); 5643 })]); 5644 }; 5645 5646 var ActiveSandbox = /*#__PURE__*/Object.freeze({ 5647 __proto__: null, 5648 events: events$2 5649 }); 5650 5651 var SandboxSchema = [ 5652 onHandler('onOpen'), 5653 onHandler('onClose'),
5654 strict$1('isPartOf'), 5655 strict$1('getAttachPoint'), 5656 defaulted$1('cloakVisibilityAttr', 'data-precloak-visibility') 5657 ]; 5658 5659 var init = function () { 5660 var contents = Cell(Optional.none()); 5661 var readState = constant('not-implemented'); 5662 var isOpen = function () { 5663 return contents.get().isSome(); 5664 }; 5665 var set = function (comp) { 5666 contents.set(Optional.some(comp)); 5667 }; 5668 var get = function () { 5669 return contents.get(); 5670 }; 5671 var clear = function () { 5672 contents.set(Optional.none()); 5673 }; 5674 return nu$5({ 5675 readState: readState, 5676 isOpen: isOpen, 5677 clear: clear, 5678 set: set, 5679 get: get 5680 }); 5681 }; 5682 5683 var SandboxState = /*#__PURE__*/Object.freeze({ 5684 __proto__: null, 5685 init: init 5686 }); 5687 5688 var Sandboxing = create$1({ 5689 fields: SandboxSchema, 5690 name: 'sandboxing', 5691 active: ActiveSandbox, 5692 apis: SandboxApis, 5693 state: SandboxState 5694 }); 5695 5696 var dismissPopups = constant('dismiss.popups'); 5697 var repositionPopups = constant('reposition.popups'); 5698 var mouseReleased = constant('mouse.released'); 5699 5700 var schema$2 = objOfOnly([ 5701 defaulted$1('isExtraPart', never), 5702 optionObjOf('fireEventInstead', [defaulted$1('event', dismissRequested())]) 5703 ]); 5704 var receivingChannel = function (rawSpec) { 5705 var _a; 5706 var detail = asRawOrDie('Dismissal', schema$2, rawSpec); 5707 return _a = {}, _a[dismissPopups()] = { 5708 schema: objOfOnly([strict$1('target')]), 5709 onReceive: function (sandbox, data) { 5710 if (Sandboxing.isOpen(sandbox)) { 5711 var isPart = Sandboxing.isPartOf(sandbox, data.target) || detail.isExtraPart(sandbox, data.target); 5712 if (!isPart) { 5713 detail.fireEventInstead.fold(function () { 5714 return Sandboxing.close(sandbox); 5715 }, function (fe) { 5716 return emit(sandbox, fe.event); 5717 }); 5718 } 5719 } 5720 } 5721 }, _a; 5722 }; 5723 5724 var schema$3 = objOfOnly([ 5725 optionObjOf('fireEventInstead', [defaulted$1('event', repositionRequested())]), 5726 strictFunction('doReposition') 5727 ]); 5728 var receivingChannel$1 = function (rawSpec) { 5729 var _a; 5730 var detail = asRawOrDie('Reposition', schema$3, rawSpec); 5731 return _a = {}, _a[repositionPopups()] = { 5732 onReceive: function (sandbox) { 5733 if (Sandboxing.isOpen(sandbox)) { 5734 detail.fireEventInstead.fold(function () { 5735 return detail.doReposition(sandbox); 5736 }, function (fe) { 5737 return emit(sandbox, fe.event); 5738 }); 5739 } 5740 } 5741 }, _a; 5742 }; 5743 5744 var onLoad = function (component, repConfig, repState) { 5745 repConfig.store.manager.onLoad(component, repConfig, repState); 5746 }; 5747 var onUnload = function (component, repConfig, repState) { 5748 repConfig.store.manager.onUnload(component, repConfig, repState); 5749 }; 5750 var setValue = function (component, repConfig, repState, data) { 5751 repConfig.store.manager.setValue(component, repConfig, repState, data); 5752 }; 5753 var getValue = function (component, repConfig, repState) { 5754 return repConfig.store.manager.getValue(component, repConfig, repState); 5755 }; 5756 var getState$1 = function (component, repConfig, repState) { 5757 return repState; 5758 }; 5759 5760 var RepresentApis = /*#__PURE__*/Object.freeze({ 5761 __proto__: null, 5762 onLoad: onLoad, 5763 onUnload: onUnload, 5764 setValue: setValue, 5765 getValue: getValue, 5766 getState: getState$1 5767 }); 5768 5769 var events$3 = function (repConfig, repState) { 5770 var es = repConfig.resetOnDom ? [ 5771 runOnAttached(function (comp, _se) { 5772 onLoad(comp, repConfig, repState); 5773 }), 5774 runOnDetached(function (comp, _se) { 5775 onUnload(comp, repConfig, repState); 5776 }) 5777 ] : [loadEvent(repConfig, repState, onLoad)]; 5778 return derive(es); 5779 }; 5780 5781 var ActiveRepresenting = /*#__PURE__*/Object.freeze({ 5782 __proto__: null, 5783 events: events$3 5784 }); 5785 5786 var memory = function () { 5787 var data = Cell(null); 5788 var readState = function () { 5789 return { 5790 mode: 'memory', 5791 value: data.get() 5792 }; 5793 }; 5794 var isNotSet = function () { 5795 return data.get() === null; 5796 }; 5797 var clear = function () { 5798 data.set(null); 5799 }; 5800 return nu$5({ 5801 set: data.set, 5802 get: data.get,
5803 isNotSet: isNotSet, 5804 clear: clear, 5805 readState: readState 5806 }); 5807 }; 5808 var manual = function () { 5809 var readState = noop; 5810 return nu$5({ readState: readState }); 5811 }; 5812 var dataset = function () { 5813 var dataByValue = Cell({}); 5814 var dataByText = Cell({}); 5815 var readState = function () { 5816 return { 5817 mode: 'dataset', 5818 dataByValue: dataByValue.get(), 5819 dataByText: dataByText.get() 5820 }; 5821 }; 5822 var clear = function () { 5823 dataByValue.set({}); 5824 dataByText.set({}); 5825 }; 5826 var lookup = function (itemString) { 5827 return get$1(dataByValue.get(), itemString).orThunk(function () { 5828 return get$1(dataByText.get(), itemString); 5829 }); 5830 }; 5831 var update = function (items) { 5832 var currentDataByValue = dataByValue.get(); 5833 var currentDataByText = dataByText.get(); 5834 var newDataByValue = {}; 5835 var newDataByText = {}; 5836 each(items, function (item) { 5837 newDataByValue[item.value] = item; 5838 get$1(item, 'meta').each(function (meta) { 5839 get$1(meta, 'text').each(function (text) { 5840 newDataByText[text] = item; 5841 }); 5842 }); 5843 }); 5844 dataByValue.set(__assign(__assign({}, currentDataByValue), newDataByValue)); 5845 dataByText.set(__assign(__assign({}, currentDataByText), newDataByText)); 5846 }; 5847 return nu$5({ 5848 readState: readState, 5849 lookup: lookup, 5850 update: update, 5851 clear: clear 5852 }); 5853 }; 5854 var init$1 = function (spec) { 5855 return spec.store.manager.state(spec); 5856 }; 5857 5858 var RepresentState = /*#__PURE__*/Object.freeze({ 5859 __proto__: null, 5860 memory: memory, 5861 dataset: dataset, 5862 manual: manual, 5863 init: init$1 5864 }); 5865 5866 var setValue$1 = function (component, repConfig, repState, data) { 5867 var store = repConfig.store; 5868 repState.update([data]); 5869 store.setValue(component, data); 5870 repConfig.onSetValue(component, data); 5871 }; 5872 var getValue$1 = function (component, repConfig, repState) { 5873 var store = repConfig.store; 5874 var key = store.getDataKey(component); 5875 return repState.lookup(key).fold(function () { 5876 return store.getFallbackEntry(key); 5877 }, function (data) { 5878 return data; 5879 }); 5880 }; 5881 var onLoad$1 = function (component, repConfig, repState) { 5882 var store = repConfig.store; 5883 store.initialValue.each(function (data) { 5884 setValue$1(component, repConfig, repState, data); 5885 }); 5886 }; 5887 var onUnload$1 = function (component, repConfig, repState) { 5888 repState.clear(); 5889 }; 5890 var DatasetStore = [ 5891 option('initialValue'), 5892 strict$1('getFallbackEntry'), 5893 strict$1('getDataKey'), 5894 strict$1('setValue'), 5895 output('manager', { 5896 setValue: setValue$1, 5897 getValue: getValue$1, 5898 onLoad: onLoad$1, 5899 onUnload: onUnload$1, 5900 state: dataset 5901 }) 5902 ]; 5903 5904 var getValue$2 = function (component, repConfig, _repState) { 5905 return repConfig.store.getValue(component); 5906 }; 5907 var setValue$2 = function (component, repConfig, _repState, data) { 5908 repConfig.store.setValue(component, data); 5909 repConfig.onSetValue(component, data); 5910 }; 5911 var onLoad$2 = function (component, repConfig, _repState) { 5912 repConfig.store.initialValue.each(function (data) { 5913 repConfig.store.setValue(component, data); 5914 }); 5915 }; 5916 var ManualStore = [ 5917 strict$1('getValue'), 5918 defaulted$1('setValue', noop), 5919 option('initialValue'), 5920 output('manager', { 5921 setValue: setValue$2, 5922 getValue: getValue$2, 5923 onLoad: onLoad$2, 5924 onUnload: noop, 5925 state: NoState.init 5926 }) 5927 ]; 5928 5929 var setValue$3 = function (component, repConfig, repState, data) { 5930 repState.set(data); 5931 repConfig.onSetValue(component, data); 5932 }; 5933 var getValue$3 = function (component, repConfig, repState) { 5934 return repState.get(); 5935 }; 5936 var onLoad$3 = function (component, repConfig, repState) { 5937 repConfig.store.initialValue.each(function (initVal) { 5938 if (repState.isNotSet()) { 5939 repState.set(initVal); 5940 } 5941 }); 5942 }; 5943 var onUnload$2 = function (component, repConfig, repState) { 5944 repState.clear(); 5945 }; 5946 var MemoryStore = [ 5947 option('initialValue'), 5948 output('manager', { 5949 setValue: setValue$3, 5950 getValue: getValue$3, 5951 onLoad: onLoad$3, 5952 onUnload: onUnload$2, 5953 state: memory 5954 }) 5955 ]; 5956 5957 var RepresentSchema = [ 5958 defaultedOf('store', { mode: 'memory' }, choose$1('mode', { 5959 memory: MemoryStore, 5960 manual: ManualStore, 5961 dataset: DatasetStore 5962 })), 5963 onHandler('onSetValue'), 5964 defaulted$1('resetOnDom', false) 5965 ]; 5966 5967 var Representing = create$1({ 5968 fields: RepresentSchema, 5969 name: 'representing', 5970 active: ActiveRepresenting, 5971 apis: RepresentApis, 5972 extra: { 5973 setValueFrom: function (component, source) { 5974 var value = Representing.getValue(source); 5975 Representing.setValue(component, value); 5976 } 5977 }, 5978 state: RepresentState 5979 }); 5980 5981 var field$1 = function (name, forbidden) { 5982 return defaultedObjOf(name, {}, map(forbidden, function (f) { 5983 return forbid(f.name(), 'Cannot configure ' + f.name() + ' for ' + name); 5984 }).concat([state$1('dump', identity)])); 5985 }; 5986 var get$d = function (data) { 5987 return data.dump; 5988 }; 5989 var augment = function (data, original) { 5990 return __assign(__assign({}, data.dump), derive$1(original)); 5991 }; 5992 var SketchBehaviours = { 5993 field: field$1, 5994 augment: augment, 5995 get: get$d 5996 }; 5997 5998 var _placeholder = 'placeholder'; 5999 var adt$9 = Adt.generate([ 6000 { 6001 single: [ 6002 'required', 6003 'valueThunk' 6004 ] 6005 }, 6006 { 6007 multiple: [ 6008 'required', 6009 'valueThunks' 6010 ] 6011 } 6012 ]); 6013 var isSubstituted = function (spec) { 6014 return has(spec, 'uiType'); 6015 }; 6016 var subPlaceholder = function (owner, detail, compSpec, placeholders) { 6017 if (owner.exists(function (o) { 6018 return o !== compSpec.owner; 6019 })) { 6020 return adt$9.single(true, constant(compSpec)); 6021 }
6022 return get$1(placeholders, compSpec.name).fold(function () { 6023 throw new Error('Unknown placeholder component: ' + compSpec.name + '\nKnown: [' + keys(placeholders) + ']\nNamespace: ' + owner.getOr('none') + '\nSpec: ' + JSON.stringify(compSpec, null, 2)); 6024 }, function (newSpec) { 6025 return newSpec.replace(); 6026 }); 6027 }; 6028 var scan = function (owner, detail, compSpec, placeholders) { 6029 if (isSubstituted(compSpec) && compSpec.uiType === _placeholder) { 6030 return subPlaceholder(owner, detail, compSpec, placeholders); 6031 } else { 6032 return adt$9.single(false, constant(compSpec)); 6033 } 6034 }; 6035 var substitute = function (owner, detail, compSpec, placeholders) { 6036 var base = scan(owner, detail, compSpec, placeholders); 6037 return base.fold(function (req, valueThunk) { 6038 var value = isSubstituted(compSpec) ? valueThunk(detail, compSpec.config, compSpec.validated) : valueThunk(detail); 6039 var childSpecs = get$1(value, 'components').getOr([]); 6040 var substituted = bind(childSpecs, function (c) { 6041 return substitute(owner, detail, c, placeholders); 6042 }); 6043 return [__assign(__assign({}, value), { components: substituted })]; 6044 }, function (req, valuesThunk) { 6045 if (isSubstituted(compSpec)) { 6046 var values = valuesThunk(detail, compSpec.config, compSpec.validated); 6047 var preprocessor = compSpec.validated.preprocess.getOr(identity); 6048 return preprocessor(values); 6049 } else { 6050 return valuesThunk(detail); 6051 } 6052 }); 6053 }; 6054 var substituteAll = function (owner, detail, components, placeholders) { 6055 return bind(components, function (c) { 6056 return substitute(owner, detail, c, placeholders); 6057 }); 6058 }; 6059 var oneReplace = function (label, replacements) { 6060 var called = false; 6061 var used = function () { 6062 return called; 6063 }; 6064 var replace = function () { 6065 if (called) { 6066 throw new Error('Trying to use the same placeholder more than once: ' + label); 6067 } 6068 called = true; 6069 return replacements; 6070 }; 6071 var required = function () { 6072 return replacements.fold(function (req, _) { 6073 return req; 6074 }, function (req, _) { 6075 return req; 6076 }); 6077 }; 6078 return { 6079 name: constant(label), 6080 required: required, 6081 used: used, 6082 replace: replace 6083 }; 6084 }; 6085 var substitutePlaces = function (owner, detail, components, placeholders) { 6086 var ps = map$2(placeholders, function (ph, name) { 6087 return oneReplace(name, ph); 6088 }); 6089 var outcome = substituteAll(owner, detail, components, ps); 6090 each$1(ps, function (p) { 6091 if (p.used() === false && p.required()) { 6092 throw new Error('Placeholder: ' + p.name() + ' was not found in components list\nNamespace: ' + owner.getOr('none') + '\nComponents: ' + JSON.stringify(detail.components, null, 2)); 6093 } 6094 }); 6095 return outcome; 6096 }; 6097 var single = adt$9.single; 6098 var multiple = adt$9.multiple; 6099 var placeholder = constant(_placeholder); 6100 6101 var adt$a = Adt.generate([ 6102 { required: ['data'] }, 6103 { external: ['data'] }, 6104 { optional: ['data'] }, 6105 { group: ['data'] } 6106 ]); 6107 var fFactory = defaulted$1('factory', { sketch: identity }); 6108 var fSchema = defaulted$1('schema', []); 6109 var fName = strict$1('name'); 6110 var fPname = field('pname', 'pname', defaultedThunk(function (typeSpec) { 6111 return '<alloy.' + generate$1(typeSpec.name) + '>'; 6112 }), anyValue$1()); 6113 var fGroupSchema = state$1('schema', function () { 6114 return [option('preprocess')]; 6115 }); 6116 var fDefaults = defaulted$1('defaults', constant({})); 6117 var fOverrides = defaulted$1('overrides', constant({})); 6118 var requiredSpec = objOf([ 6119 fFactory, 6120 fSchema, 6121 fName, 6122 fPname, 6123 fDefaults, 6124 fOverrides 6125 ]); 6126 var externalSpec = objOf([ 6127 fFactory, 6128 fSchema, 6129 fName, 6130 fDefaults, 6131 fOverrides 6132 ]); 6133 var optionalSpec = objOf([ 6134 fFactory, 6135 fSchema, 6136 fName, 6137 fPname, 6138 fDefaults, 6139 fOverrides 6140 ]); 6141 var groupSpec = objOf([ 6142 fFactory, 6143 fGroupSchema, 6144 fName,
6145 strict$1('unit'), 6146 fPname, 6147 fDefaults, 6148 fOverrides 6149 ]); 6150 var asNamedPart = function (part) { 6151 return part.fold(Optional.some, Optional.none, Optional.some, Optional.some); 6152 }; 6153 var name$1 = function (part) { 6154 var get = function (data) { 6155 return data.name; 6156 }; 6157 return part.fold(get, get, get, get); 6158 }; 6159 var asCommon = function (part) { 6160 return part.fold(identity, identity, identity, identity); 6161 }; 6162 var convert = function (adtConstructor, partSchema) { 6163 return function (spec) { 6164 var data = asRawOrDie('Converting part type', partSchema, spec); 6165 return adtConstructor(data); 6166 }; 6167 }; 6168 var required = convert(adt$a.required, requiredSpec); 6169 var external$1 = convert(adt$a.external, externalSpec); 6170 var optional = convert(adt$a.optional, optionalSpec); 6171 var group = convert(adt$a.group, groupSpec); 6172 var original = constant('entirety'); 6173 6174 var PartType = /*#__PURE__*/Object.freeze({ 6175 __proto__: null, 6176 required: required, 6177 external: external$1, 6178 optional: optional, 6179 group: group, 6180 asNamedPart: asNamedPart, 6181 name: name$1, 6182 asCommon: asCommon, 6183 original: original 6184 }); 6185 6186 var combine$2 = function (detail, data, partSpec, partValidated) { 6187 return deepMerge(data.defaults(detail, partSpec, partValidated), partSpec, { uid: detail.partUids[data.name] }, data.overrides(detail, partSpec, partValidated)); 6188 }; 6189 var subs = function (owner, detail, parts) { 6190 var internals = {}; 6191 var externals = {}; 6192 each(parts, function (part) { 6193 part.fold(function (data) { 6194 internals[data.pname] = single(true, function (detail, partSpec, partValidated) { 6195 return data.factory.sketch(combine$2(detail, data, partSpec, partValidated)); 6196 }); 6197 }, function (data) { 6198 var partSpec = detail.parts[data.name]; 6199 externals[data.name] = constant(data.factory.sketch(combine$2(detail, data, partSpec[original()]), partSpec)); 6200 }, function (data) { 6201 internals[data.pname] = single(false, function (detail, partSpec, partValidated) { 6202 return data.factory.sketch(combine$2(detail, data, partSpec, partValidated)); 6203 }); 6204 }, function (data) { 6205 internals[data.pname] = multiple(true, function (detail, _partSpec, _partValidated) { 6206 var units = detail[data.name]; 6207 return map(units, function (u) { 6208 return data.factory.sketch(deepMerge(data.defaults(detail, u, _partValidated), u, data.overrides(detail, u))); 6209 }); 6210 }); 6211 }); 6212 }); 6213 return { 6214 internals: constant(internals), 6215 externals: constant(externals) 6216 }; 6217 }; 6218 6219 var generate$4 = function (owner, parts) { 6220 var r = {}; 6221 each(parts, function (part) { 6222 asNamedPart(part).each(function (np) { 6223 var g = doGenerateOne(owner, np.pname); 6224 r[np.name] = function (config) { 6225 var validated = asRawOrDie('Part: ' + np.name + ' in ' + owner, objOf(np.schema), config); 6226 return __assign(__assign({}, g), { 6227 config: config, 6228 validated: validated 6229 }); 6230 }; 6231 }); 6232 }); 6233 return r; 6234 }; 6235 var doGenerateOne = function (owner, pname) { 6236 return { 6237 uiType: placeholder(), 6238 owner: owner, 6239 name: pname 6240 }; 6241 }; 6242 var generateOne = function (owner, pname, config) { 6243 return { 6244 uiType: placeholder(), 6245 owner: owner, 6246 name: pname, 6247 config: config, 6248 validated: {} 6249 }; 6250 }; 6251 var schemas = function (parts) { 6252 return bind(parts, function (part) { 6253 return part.fold(Optional.none, Optional.some, Optional.none, Optional.none).map(function (data) { 6254 return strictObjOf(data.name, data.schema.concat([snapshot(original())])); 6255 }).toArray(); 6256 }); 6257 }; 6258 var names = function (parts) { 6259 return map(parts, name$1); 6260 }; 6261 var substitutes = function (owner, detail, parts) { 6262 return subs(owner, detail, parts); 6263 }; 6264 var components = function (owner, detail, internals) { 6265 return substitutePlaces(Optional.some(owner), detail, detail.components, internals); 6266 }; 6267 var getPart = function (component, detail, partKey) { 6268 var uid = detail.partUids[partKey]; 6269 return component.getSystem().getByUid(uid).toOptional(); 6270 }; 6271 var getPartOrDie = function (component, detail, partKey) { 6272 return getPart(component, detail, partKey).getOrDie('Could not find part: ' + partKey); 6273 }; 6274 var getParts = function (component, detail, partKeys) { 6275 var r = {}; 6276 var uids = detail.partUids; 6277 var system = component.getSystem(); 6278 each(partKeys, function (pk) { 6279 r[pk] = constant(system.getByUid(uids[pk])); 6280 }); 6281 return r; 6282 }; 6283 var getAllParts = function (component, detail) { 6284 var system = component.getSystem(); 6285 return map$2(detail.partUids, function (pUid, _k) { 6286 return constant(system.getByUid(pUid)); 6287 }); 6288 }; 6289 var getAllPartNames = function (detail) { 6290 return keys(detail.partUids); 6291 }; 6292 var getPartsOrDie = function (component, detail, partKeys) { 6293 var r = {}; 6294 var uids = detail.partUids; 6295 var system = component.getSystem(); 6296 each(partKeys, function (pk) { 6297 r[pk] = constant(system.getByUid(uids[pk]).getOrDie()); 6298 }); 6299 return r; 6300 }; 6301 var defaultUids = function (baseUid, partTypes) { 6302 var partNames = names(partTypes); 6303 return wrapAll$1(map(partNames, function (pn) { 6304 return { 6305 key: pn, 6306 value: baseUid + '-' + pn 6307 }; 6308 })); 6309 }; 6310 var defaultUidsSchema = function (partTypes) { 6311 return field('partUids', 'partUids', mergeWithThunk(function (spec) { 6312 return defaultUids(spec.uid, partTypes); 6313 }), anyValue$1()); 6314 }; 6315 6316 var AlloyParts = /*#__PURE__*/Object.freeze({ 6317 __proto__: null, 6318 generate: generate$4, 6319 generateOne: generateOne, 6320 schemas: schemas, 6321 names: names, 6322 substitutes: substitutes, 6323 components: components, 6324 defaultUids: defaultUids, 6325 defaultUidsSchema: defaultUidsSchema, 6326 getAllParts: getAllParts, 6327 getAllPartNames: getAllPartNames, 6328 getPart: getPart, 6329 getPartOrDie: getPartOrDie, 6330 getParts: getParts, 6331 getPartsOrDie: getPartsOrDie 6332 }); 6333 6334 var base = function (partSchemas, partUidsSchemas) { 6335 var ps = partSchemas.length > 0 ? [strictObjOf('parts', partSchemas)] : []; 6336 return ps.concat([
6337 strict$1('uid'), 6338 defaulted$1('dom', {}), 6339 defaulted$1('components', []), 6340 snapshot('originalSpec'), 6341 defaulted$1('debug.sketcher', {}) 6342 ]).concat(partUidsSchemas); 6343 }; 6344 var asRawOrDie$1 = function (label, schema, spec, partSchemas, partUidsSchemas) { 6345 var baseS = base(partSchemas, partUidsSchemas); 6346 return asRawOrDie(label + ' [SpecSchema]', objOfOnly(baseS.concat(schema)), spec); 6347 }; 6348 6349 var single$1 = function (owner, schema, factory, spec) { 6350 var specWithUid = supplyUid(spec); 6351 var detail = asRawOrDie$1(owner, schema, specWithUid, [], []); 6352 return factory(detail, specWithUid); 6353 }; 6354 var composite = function (owner, schema, partTypes, factory, spec) { 6355 var specWithUid = supplyUid(spec); 6356 var partSchemas = schemas(partTypes); 6357 var partUidsSchema = defaultUidsSchema(partTypes); 6358 var detail = asRawOrDie$1(owner, schema, specWithUid, partSchemas, [partUidsSchema]); 6359 var subs = substitutes(owner, detail, partTypes); 6360 var components$1 = components(owner, detail, subs.internals()); 6361 return factory(detail, components$1, specWithUid, subs.externals()); 6362 }; 6363 var hasUid = function (spec) { 6364 return has(spec, 'uid'); 6365 }; 6366 var supplyUid = function (spec) { 6367 return hasUid(spec) ? spec : __assign(__assign({}, spec), { uid: generate$2('uid') }); 6368 }; 6369 6370 var isSketchSpec = function (spec) { 6371 return spec.uid !== undefined; 6372 }; 6373 var singleSchema = objOfOnly([ 6374 strict$1('name'), 6375 strict$1('factory'), 6376 strict$1('configFields'), 6377 defaulted$1('apis', {}), 6378 defaulted$1('extraApis', {}) 6379 ]); 6380 var compositeSchema = objOfOnly([ 6381 strict$1('name'), 6382 strict$1('factory'), 6383 strict$1('configFields'), 6384 strict$1('partFields'), 6385 defaulted$1('apis', {}), 6386 defaulted$1('extraApis', {}) 6387 ]); 6388 var single$2 = function (rawConfig) { 6389 var config = asRawOrDie('Sketcher for ' + rawConfig.name, singleSchema, rawConfig); 6390 var sketch = function (spec) { 6391 return single$1(config.name, config.configFields, config.factory, spec); 6392 }; 6393 var apis = map$2(config.apis, makeApi); 6394 var extraApis = map$2(config.extraApis, function (f, k) { 6395 return markAsExtraApi(f, k); 6396 }); 6397 return __assign(__assign({ 6398 name: config.name, 6399 configFields: config.configFields, 6400 sketch: sketch 6401 }, apis), extraApis); 6402 }; 6403 var composite$1 = function (rawConfig) { 6404 var config = asRawOrDie('Sketcher for ' + rawConfig.name, compositeSchema, rawConfig); 6405 var sketch = function (spec) { 6406 return composite(config.name, config.configFields, config.partFields, config.factory, spec); 6407 }; 6408 var parts = generate$4(config.name, config.partFields); 6409 var apis = map$2(config.apis, makeApi); 6410 var extraApis = map$2(config.extraApis, function (f, k) { 6411 return markAsExtraApi(f, k); 6412 }); 6413 return __assign(__assign({ 6414 name: config.name, 6415 partFields: config.partFields, 6416 configFields: config.configFields, 6417 sketch: sketch, 6418 parts: parts 6419 }, apis), extraApis); 6420 }; 6421 6422 var cat = function (arr) { 6423 var r = []; 6424 var push = function (x) { 6425 r.push(x); 6426 }; 6427 for (var i = 0; i < arr.length; i++) { 6428 arr[i].each(push); 6429 } 6430 return r; 6431 }; 6432 var sequence = function (arr) { 6433 var r = []; 6434 for (var i = 0; i < arr.length; i++) { 6435 var x = arr[i]; 6436 if (x.isSome()) { 6437 r.push(x.getOrDie()); 6438 } else { 6439 return Optional.none(); 6440 } 6441 } 6442 return Optional.some(r); 6443 }; 6444 var lift2 = function (oa, ob, f) { 6445 return oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none(); 6446 }; 6447 var lift3 = function (oa, ob, oc, f) { 6448 return oa.isSome() && ob.isSome() && oc.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie(), oc.getOrDie())) : Optional.none(); 6449 }; 6450 var mapFrom = function (a, f) { 6451 return a !== undefined && a !== null ? Optional.some(f(a)) : Optional.none(); 6452 }; 6453 var someIf = function (b, a) { 6454 return b ? Optional.some(a) : Optional.none(); 6455 }; 6456 6457 var inside = function (target) { 6458 return name(target) === 'input' && get$3(target, 'type') !== 'radio' || name(target) === 'textarea'; 6459 }; 6460 6461 var getCurrent = function (component, composeConfig, _composeState) { 6462 return composeConfig.find(component); 6463 }; 6464 6465 var ComposeApis = /*#__PURE__*/Object.freeze({ 6466 __proto__: null, 6467 getCurrent: getCurrent 6468 }); 6469 6470 var ComposeSchema = [strict$1('find')]; 6471 6472 var Composing = create$1({ 6473 fields: ComposeSchema, 6474 name: 'composing', 6475 apis: ComposeApis 6476 }); 6477 6478 var dehighlightAllExcept = function (component, hConfig, hState, skip) { 6479 var highlighted = descendants(component.element, '.' + hConfig.highlightClass); 6480 each(highlighted, function (h) { 6481 if (!exists(skip, function (skipComp) { 6482 return skipComp.element === h; 6483 })) { 6484 remove$4(h, hConfig.highlightClass); 6485 component.getSystem().getByDom(h).each(function (target) { 6486 hConfig.onDehighlight(component, target); 6487 emit(target, dehighlight()); 6488 }); 6489 } 6490 }); 6491 }; 6492 var dehighlightAll = function (component, hConfig, hState) { 6493 return dehighlightAllExcept(component, hConfig, hState, []); 6494 }; 6495 var dehighlight$1 = function (component, hConfig, hState, target) { 6496 if (isHighlighted(component, hConfig, hState, target)) { 6497 remove$4(target.element, hConfig.highlightClass); 6498 hConfig.onDehighlight(component, target); 6499 emit(target, dehighlight()); 6500 } 6501 }; 6502 var highlight$1 = function (component, hConfig, hState, target) { 6503 dehighlightAllExcept(component, hConfig, hState, [target]); 6504 if (!isHighlighted(component, hConfig, hState, target)) { 6505 add$2(target.element, hConfig.highlightClass); 6506 hConfig.onHighlight(component, target); 6507 emit(target, highlight()); 6508 } 6509 }; 6510 var highlightFirst = function (component, hConfig, hState) { 6511 getFirst(component, hConfig).each(function (firstComp) { 6512 highlight$1(component, hConfig, hState, firstComp); 6513 }); 6514 }; 6515 var highlightLast = function (component, hConfig, hState) { 6516 getLast(component, hConfig).each(function (lastComp) { 6517 highlight$1(component, hConfig, hState, lastComp); 6518 }); 6519 }; 6520 var highlightAt = function (component, hConfig, hState, index) { 6521 getByIndex(component, hConfig, hState, index).fold(function (err) { 6522 throw err; 6523 }, function (firstComp) { 6524 highlight$1(component, hConfig, hState, firstComp); 6525 }); 6526 };
6527 var highlightBy = function (component, hConfig, hState, predicate) { 6528 var candidates = getCandidates(component, hConfig); 6529 var targetComp = find(candidates, predicate); 6530 targetComp.each(function (c) { 6531 highlight$1(component, hConfig, hState, c); 6532 }); 6533 }; 6534 var isHighlighted = function (component, hConfig, hState, queryTarget) { 6535 return has$2(queryTarget.element, hConfig.highlightClass); 6536 }; 6537 var getHighlighted = function (component, hConfig, _hState) { 6538 return descendant$1(component.element, '.' + hConfig.highlightClass).bind(function (e) { 6539 return component.getSystem().getByDom(e).toOptional(); 6540 }); 6541 }; 6542 var getByIndex = function (component, hConfig, hState, index) { 6543 var items = descendants(component.element, '.' + hConfig.itemClass); 6544 return Optional.from(items[index]).fold(function () { 6545 return Result.error(new Error('No element found with index ' + index)); 6546 }, component.getSystem().getByDom); 6547 }; 6548 var getFirst = function (component, hConfig, _hState) { 6549 return descendant$1(component.element, '.' + hConfig.itemClass).bind(function (e) { 6550 return component.getSystem().getByDom(e).toOptional(); 6551 }); 6552 }; 6553 var getLast = function (component, hConfig, _hState) { 6554 var items = descendants(component.element, '.' + hConfig.itemClass); 6555 var last = items.length > 0 ? Optional.some(items[items.length - 1]) : Optional.none(); 6556 return last.bind(function (c) { 6557 return component.getSystem().getByDom(c).toOptional(); 6558 }); 6559 }; 6560 var getDelta = function (component, hConfig, hState, delta) { 6561 var items = descendants(component.element, '.' + hConfig.itemClass); 6562 var current = findIndex(items, function (item) { 6563 return has$2(item, hConfig.highlightClass); 6564 }); 6565 return current.bind(function (selected) { 6566 var dest = cycleBy(selected, delta, 0, items.length - 1); 6567 return component.getSystem().getByDom(items[dest]).toOptional(); 6568 }); 6569 }; 6570 var getPrevious = function (component, hConfig, hState) { 6571 return getDelta(component, hConfig, hState, -1); 6572 }; 6573 var getNext = function (component, hConfig, hState) { 6574 return getDelta(component, hConfig, hState, +1); 6575 }; 6576 var getCandidates = function (component, hConfig, _hState) { 6577 var items = descendants(component.element, '.' + hConfig.itemClass); 6578 return cat(map(items, function (i) { 6579 return component.getSystem().getByDom(i).toOptional(); 6580 })); 6581 }; 6582 6583 var HighlightApis = /*#__PURE__*/Object.freeze({ 6584 __proto__: null, 6585 dehighlightAll: dehighlightAll, 6586 dehighlight: dehighlight$1, 6587 highlight: highlight$1, 6588 highlightFirst: highlightFirst, 6589 highlightLast: highlightLast, 6590 highlightAt: highlightAt, 6591 highlightBy: highlightBy, 6592 isHighlighted: isHighlighted, 6593 getHighlighted: getHighlighted, 6594 getFirst: getFirst, 6595 getLast: getLast, 6596 getPrevious: getPrevious, 6597 getNext: getNext, 6598 getCandidates: getCandidates 6599 }); 6600 6601 var HighlightSchema = [ 6602 strict$1('highlightClass'), 6603 strict$1('itemClass'), 6604 onHandler('onHighlight'), 6605 onHandler('onDehighlight') 6606 ]; 6607 6608 var Highlighting = create$1({ 6609 fields: HighlightSchema, 6610 name: 'highlighting', 6611 apis: HighlightApis 6612 }); 6613 6614 var BACKSPACE = [8]; 6615 var TAB = [9]; 6616 var ENTER = [13]; 6617 var ESCAPE = [27]; 6618 var SPACE = [32]; 6619 var LEFT = [37]; 6620 var UP = [38]; 6621 var RIGHT = [39]; 6622 var DOWN = [40]; 6623 6624 var cyclePrev = function (values, index, predicate) { 6625 var before = reverse(values.slice(0, index)); 6626 var after = reverse(values.slice(index + 1)); 6627 return find(before.concat(after), predicate); 6628 }; 6629 var tryPrev = function (values, index, predicate) { 6630 var before = reverse(values.slice(0, index)); 6631 return find(before, predicate); 6632 }; 6633 var cycleNext = function (values, index, predicate) { 6634 var before = values.slice(0, index); 6635 var after = values.slice(index + 1); 6636 return find(after.concat(before), predicate); 6637 }; 6638 var tryNext = function (values, index, predicate) { 6639 var after = values.slice(index + 1); 6640 return find(after, predicate); 6641 }; 6642 6643 var inSet = function (keys) { 6644 return function (event) { 6645 var raw = event.raw; 6646 return contains(keys, raw.which); 6647 }; 6648 }; 6649 var and = function (preds) { 6650 return function (event) { 6651 return forall(preds, function (pred) { 6652 return pred(event); 6653 }); 6654 }; 6655 }; 6656 var isShift = function (event) { 6657 var raw = event.raw; 6658 return raw.shiftKey === true; 6659 }; 6660 var isControl = function (event) { 6661 var raw = event.raw; 6662 return raw.ctrlKey === true; 6663 }; 6664 var isNotShift = not(isShift); 6665 6666 var rule = function (matches, action) { 6667 return { 6668 matches: matches, 6669 classification: action 6670 }; 6671 }; 6672 var choose$2 = function (transitions, event) { 6673 var transition = find(transitions, function (t) { 6674 return t.matches(event); 6675 }); 6676 return transition.map(function (t) { 6677 return t.classification; 6678 }); 6679 }; 6680 6681 var reportFocusShifting = function (component, prevFocus, newFocus) { 6682 var noChange = prevFocus.exists(function (p) { 6683 return newFocus.exists(function (n) { 6684 return eq$1(n, p); 6685 }); 6686 }); 6687 if (!noChange) { 6688 emitWith(component, focusShifted(), { 6689 prevFocus: prevFocus, 6690 newFocus: newFocus 6691 }); 6692 } 6693 }; 6694 var dom = function () { 6695 var get = function (component) { 6696 return search(component.element); 6697 }; 6698 var set = function (component, focusee) { 6699 var prevFocus = get(component); 6700 component.getSystem().triggerFocus(focusee, component.element); 6701 var newFocus = get(component); 6702 reportFocusShifting(component, prevFocus, newFocus); 6703 }; 6704 return { 6705 get: get, 6706 set: set 6707 }; 6708 }; 6709 var highlights = function () { 6710 var get = function (component) { 6711 return Highlighting.getHighlighted(component).map(function (item) { 6712 return item.element; 6713 }); 6714 }; 6715 var set = function (component, element) { 6716 var prevFocus = get(component); 6717 component.getSystem().getByDom(element).fold(noop, function (item) { 6718 Highlighting.highlight(component, item); 6719 }); 6720 var newFocus = get(component); 6721 reportFocusShifting(component, prevFocus, newFocus); 6722 }; 6723 return { 6724 get: get, 6725 set: set 6726 }; 6727 }; 6728 6729 var FocusInsideModes;
6730 (function (FocusInsideModes) { 6731 FocusInsideModes['OnFocusMode'] = 'onFocus'; 6732 FocusInsideModes['OnEnterOrSpaceMode'] = 'onEnterOrSpace'; 6733 FocusInsideModes['OnApiMode'] = 'onApi'; 6734 }(FocusInsideModes || (FocusInsideModes = {}))); 6735 6736 var typical = function (infoSchema, stateInit, getKeydownRules, getKeyupRules, optFocusIn) { 6737 var schema = function () { 6738 return infoSchema.concat([ 6739 defaulted$1('focusManager', dom()), 6740 defaultedOf('focusInside', 'onFocus', valueOf(function (val) { 6741 return contains([ 6742 'onFocus', 6743 'onEnterOrSpace', 6744 'onApi' 6745 ], val) ? Result.value(val) : Result.error('Invalid value for focusInside'); 6746 })), 6747 output('handler', me), 6748 output('state', stateInit), 6749 output('sendFocusIn', optFocusIn) 6750 ]); 6751 }; 6752 var processKey = function (component, simulatedEvent, getRules, keyingConfig, keyingState) { 6753 var rules = getRules(component, simulatedEvent, keyingConfig, keyingState); 6754 return choose$2(rules, simulatedEvent.event).bind(function (rule) { 6755 return rule(component, simulatedEvent, keyingConfig, keyingState); 6756 }); 6757 }; 6758 var toEvents = function (keyingConfig, keyingState) { 6759 var onFocusHandler = keyingConfig.focusInside !== FocusInsideModes.OnFocusMode ? Optional.none() : optFocusIn(keyingConfig).map(function (focusIn) { 6760 return run(focus(), function (component, simulatedEvent) { 6761 focusIn(component, keyingConfig, keyingState); 6762 simulatedEvent.stop(); 6763 }); 6764 }); 6765 var tryGoInsideComponent = function (component, simulatedEvent) { 6766 var isEnterOrSpace = inSet(SPACE.concat(ENTER))(simulatedEvent.event); 6767 if (keyingConfig.focusInside === FocusInsideModes.OnEnterOrSpaceMode && isEnterOrSpace && isSource(component, simulatedEvent)) { 6768 optFocusIn(keyingConfig).each(function (focusIn) { 6769 focusIn(component, keyingConfig, keyingState); 6770 simulatedEvent.stop(); 6771 }); 6772 } 6773 }; 6774 var keyboardEvents = [ 6775 run(keydown(), function (component, simulatedEvent) { 6776 processKey(component, simulatedEvent, getKeydownRules, keyingConfig, keyingState).fold(function () { 6777 tryGoInsideComponent(component, simulatedEvent); 6778 }, function (_) { 6779 simulatedEvent.stop(); 6780 }); 6781 }), 6782 run(keyup(), function (component, simulatedEvent) { 6783 processKey(component, simulatedEvent, getKeyupRules, keyingConfig, keyingState).each(function (_) { 6784 simulatedEvent.stop(); 6785 }); 6786 }) 6787 ]; 6788 return derive(onFocusHandler.toArray().concat(keyboardEvents)); 6789 }; 6790 var me = { 6791 schema: schema, 6792 processKey: processKey, 6793 toEvents: toEvents 6794 }; 6795 return me; 6796 }; 6797 6798 var create$3 = function (cyclicField) { 6799 var schema = [ 6800 option('onEscape'), 6801 option('onEnter'), 6802 defaulted$1('selector', '[data-alloy-tabstop="true"]:not(:disabled)'), 6803 defaulted$1('firstTabstop', 0), 6804 defaulted$1('useTabstopAt', always), 6805 option('visibilitySelector') 6806 ].concat([cyclicField]); 6807 var isVisible = function (tabbingConfig, element) { 6808 var target = tabbingConfig.visibilitySelector.bind(function (sel) { 6809 return closest$3(element, sel); 6810 }).getOr(element); 6811 return get$7(target) > 0; 6812 }; 6813 var findInitial = function (component, tabbingConfig) { 6814 var tabstops = descendants(component.element, tabbingConfig.selector); 6815 var visibles = filter(tabstops, function (elem) { 6816 return isVisible(tabbingConfig, elem); 6817 }); 6818 return Optional.from(visibles[tabbingConfig.firstTabstop]); 6819 }; 6820 var findCurrent = function (component, tabbingConfig) { 6821 return tabbingConfig.focusManager.get(component).bind(function (elem) { 6822 return closest$3(elem, tabbingConfig.selector); 6823 }); 6824 }; 6825 var isTabstop = function (tabbingConfig, element) { 6826 return isVisible(tabbingConfig, element) && tabbingConfig.useTabstopAt(element); 6827 }; 6828 var focusIn = function (component, tabbingConfig, _tabbingState) { 6829 findInitial(component, tabbingConfig).each(function (target) { 6830 tabbingConfig.focusManager.set(component, target); 6831 }); 6832 }; 6833 var goFromTabstop = function (component, tabstops, stopIndex, tabbingConfig, cycle) { 6834 return cycle(tabstops, stopIndex, function (elem) { 6835 return isTabstop(tabbingConfig, elem); 6836 }).fold(function () { 6837 return tabbingConfig.cyclic ? Optional.some(true) : Optional.none(); 6838 }, function (target) { 6839 tabbingConfig.focusManager.set(component, target); 6840 return Optional.some(true); 6841 }); 6842 }; 6843 var go = function (component, _simulatedEvent, tabbingConfig, cycle) { 6844 var tabstops = descendants(component.element, tabbingConfig.selector); 6845 return findCurrent(component, tabbingConfig).bind(function (tabstop) { 6846 var optStopIndex = findIndex(tabstops, curry(eq$1, tabstop)); 6847 return optStopIndex.bind(function (stopIndex) { 6848 return goFromTabstop(component, tabstops, stopIndex, tabbingConfig, cycle); 6849 }); 6850 }); 6851 }; 6852 var goBackwards = function (component, simulatedEvent, tabbingConfig) { 6853 var navigate = tabbingConfig.cyclic ? cyclePrev : tryPrev; 6854 return go(component, simulatedEvent, tabbingConfig, navigate); 6855 }; 6856 var goForwards = function (component, simulatedEvent, tabbingConfig) { 6857 var navigate = tabbingConfig.cyclic ? cycleNext : tryNext; 6858 return go(component, simulatedEvent, tabbingConfig, navigate); 6859 }; 6860 var execute = function (component, simulatedEvent, tabbingConfig) { 6861 return tabbingConfig.onEnter.bind(function (f) { 6862 return f(component, simulatedEvent); 6863 }); 6864 }; 6865 var exit = function (component, simulatedEvent, tabbingConfig) { 6866 return tabbingConfig.onEscape.bind(function (f) { 6867 return f(component, simulatedEvent); 6868 }); 6869 }; 6870 var getKeydownRules = constant([ 6871 rule(and([ 6872 isShift, 6873 inSet(TAB) 6874 ]), goBackwards), 6875 rule(inSet(TAB), goForwards), 6876 rule(inSet(ESCAPE), exit), 6877 rule(and([ 6878 isNotShift, 6879 inSet(ENTER) 6880 ]), execute) 6881 ]); 6882 var getKeyupRules = constant([]);
6883 return typical(schema, NoState.init, getKeydownRules, getKeyupRules, function () { 6884 return Optional.some(focusIn); 6885 }); 6886 }; 6887 6888 var AcyclicType = create$3(state$1('cyclic', never)); 6889 6890 var CyclicType = create$3(state$1('cyclic', always)); 6891 6892 var doDefaultExecute = function (component, _simulatedEvent, focused) { 6893 dispatch(component, focused, execute()); 6894 return Optional.some(true); 6895 }; 6896 var defaultExecute = function (component, simulatedEvent, focused) { 6897 var isComplex = inside(focused) && inSet(SPACE)(simulatedEvent.event); 6898 return isComplex ? Optional.none() : doDefaultExecute(component, simulatedEvent, focused); 6899 }; 6900 var stopEventForFirefox = function (_component, _simulatedEvent) { 6901 return Optional.some(true); 6902 }; 6903 6904 var schema$4 = [ 6905 defaulted$1('execute', defaultExecute), 6906 defaulted$1('useSpace', false), 6907 defaulted$1('useEnter', true), 6908 defaulted$1('useControlEnter', false), 6909 defaulted$1('useDown', false) 6910 ]; 6911 var execute$1 = function (component, simulatedEvent, executeConfig) { 6912 return executeConfig.execute(component, simulatedEvent, component.element); 6913 }; 6914 var getKeydownRules = function (component, _simulatedEvent, executeConfig, _executeState) { 6915 var spaceExec = executeConfig.useSpace && !inside(component.element) ? SPACE : []; 6916 var enterExec = executeConfig.useEnter ? ENTER : []; 6917 var downExec = executeConfig.useDown ? DOWN : []; 6918 var execKeys = spaceExec.concat(enterExec).concat(downExec); 6919 return [rule(inSet(execKeys), execute$1)].concat(executeConfig.useControlEnter ? [rule(and([ 6920 isControl, 6921 inSet(ENTER) 6922 ]), execute$1)] : []); 6923 }; 6924 var getKeyupRules = function (component, _simulatedEvent, executeConfig, _executeState) { 6925 return executeConfig.useSpace && !inside(component.element) ? [rule(inSet(SPACE), stopEventForFirefox)] : []; 6926 }; 6927 var ExecutionType = typical(schema$4, NoState.init, getKeydownRules, getKeyupRules, function () { 6928 return Optional.none(); 6929 }); 6930 6931 var flatgrid = function () { 6932 var dimensions = Cell(Optional.none()); 6933 var setGridSize = function (numRows, numColumns) { 6934 dimensions.set(Optional.some({ 6935 numRows: numRows, 6936 numColumns: numColumns 6937 })); 6938 }; 6939 var getNumRows = function () { 6940 return dimensions.get().map(function (d) { 6941 return d.numRows; 6942 }); 6943 }; 6944 var getNumColumns = function () { 6945 return dimensions.get().map(function (d) { 6946 return d.numColumns; 6947 }); 6948 }; 6949 return nu$5({ 6950 readState: function () { 6951 return dimensions.get().map(function (d) { 6952 return { 6953 numRows: String(d.numRows), 6954 numColumns: String(d.numColumns) 6955 }; 6956 }).getOr({ 6957 numRows: '?', 6958 numColumns: '?' 6959 }); 6960 }, 6961 setGridSize: setGridSize, 6962 getNumRows: getNumRows, 6963 getNumColumns: getNumColumns 6964 }); 6965 }; 6966 var init$2 = function (spec) { 6967 return spec.state(spec); 6968 }; 6969 6970 var KeyingState = /*#__PURE__*/Object.freeze({ 6971 __proto__: null, 6972 flatgrid: flatgrid, 6973 init: init$2 6974 }); 6975 6976 var useH = function (movement) { 6977 return function (component, simulatedEvent, config, state) { 6978 var move = movement(component.element); 6979 return use(move, component, simulatedEvent, config, state); 6980 }; 6981 }; 6982 var west$2 = function (moveLeft, moveRight) { 6983 var movement = onDirection(moveLeft, moveRight); 6984 return useH(movement); 6985 }; 6986 var east$2 = function (moveLeft, moveRight) { 6987 var movement = onDirection(moveRight, moveLeft); 6988 return useH(movement); 6989 }; 6990 var useV = function (move) { 6991 return function (component, simulatedEvent, config, state) { 6992 return use(move, component, simulatedEvent, config, state); 6993 }; 6994 }; 6995 var use = function (move, component, simulatedEvent, config, state) { 6996 var outcome = config.focusManager.get(component).bind(function (focused) { 6997 return move(component.element, focused, config, state); 6998 }); 6999 return outcome.map(function (newFocus) { 7000 config.focusManager.set(component, newFocus); 7001 return true; 7002 }); 7003 }; 7004 var north$2 = useV; 7005 var south$2 = useV; 7006 var move = useV; 7007 7008 var isHidden = function (dom) { 7009 return dom.offsetWidth <= 0 && dom.offsetHeight <= 0; 7010 }; 7011 var isVisible = function (element) { 7012 return !isHidden(element.dom); 7013 }; 7014 7015 var locate = function (candidates, predicate) { 7016 return findIndex(candidates, predicate).map(function (index) { 7017 return { 7018 index: index, 7019 candidates: candidates 7020 }; 7021 }); 7022 }; 7023 7024 var locateVisible = function (container, current, selector) { 7025 var predicate = function (x) { 7026 return eq$1(x, current); 7027 }; 7028 var candidates = descendants(container, selector); 7029 var visible = filter(candidates, isVisible); 7030 return locate(visible, predicate); 7031 }; 7032 var findIndex$1 = function (elements, target) { 7033 return findIndex(elements, function (elem) { 7034 return eq$1(target, elem); 7035 }); 7036 }; 7037 7038 var withGrid = function (values, index, numCols, f) { 7039 var oldRow = Math.floor(index / numCols); 7040 var oldColumn = index % numCols; 7041 return f(oldRow, oldColumn).bind(function (address) { 7042 var newIndex = address.row * numCols + address.column; 7043 return newIndex >= 0 && newIndex < values.length ? Optional.some(values[newIndex]) : Optional.none(); 7044 }); 7045 }; 7046 var cycleHorizontal = function (values, index, numRows, numCols, delta) { 7047 return withGrid(values, index, numCols, function (oldRow, oldColumn) { 7048 var onLastRow = oldRow === numRows - 1; 7049 var colsInRow = onLastRow ? values.length - oldRow * numCols : numCols; 7050 var newColumn = cycleBy(oldColumn, delta, 0, colsInRow - 1); 7051 return Optional.some({ 7052 row: oldRow, 7053 column: newColumn 7054 }); 7055 }); 7056 }; 7057 var cycleVertical = function (values, index, numRows, numCols, delta) { 7058 return withGrid(values, index, numCols, function (oldRow, oldColumn) { 7059 var newRow = cycleBy(oldRow, delta, 0, numRows - 1); 7060 var onLastRow = newRow === numRows - 1; 7061 var colsInRow = onLastRow ? values.length - newRow * numCols : numCols; 7062 var newCol = clamp(oldColumn, 0, colsInRow - 1); 7063 return Optional.some({ 7064 row: newRow, 7065 column: newCol 7066 }); 7067 }); 7068 }; 7069 var cycleRight = function (values, index, numRows, numCols) { 7070 return cycleHorizontal(values, index, numRows, numCols, +1); 7071 }; 7072 var cycleLeft = function (values, index, numRows, numCols) { 7073 return cycleHorizontal(values, index, numRows, numCols, -1); 7074 }; 7075 var cycleUp = function (values, index, numRows, numCols) { 7076 return cycleVertical(values, index, numRows, numCols, -1); 7077 }; 7078 var cycleDown = function (values, index, numRows, numCols) { 7079 return cycleVertical(values, index, numRows, numCols, +1); 7080 }; 7081 7082 var schema$5 = [
7083 strict$1('selector'), 7084 defaulted$1('execute', defaultExecute), 7085 onKeyboardHandler('onEscape'), 7086 defaulted$1('captureTab', false), 7087 initSize() 7088 ]; 7089 var focusIn = function (component, gridConfig, _gridState) { 7090 descendant$1(component.element, gridConfig.selector).each(function (first) { 7091 gridConfig.focusManager.set(component, first); 7092 }); 7093 }; 7094 var findCurrent = function (component, gridConfig) { 7095 return gridConfig.focusManager.get(component).bind(function (elem) { 7096 return closest$3(elem, gridConfig.selector); 7097 }); 7098 }; 7099 var execute$2 = function (component, simulatedEvent, gridConfig, _gridState) { 7100 return findCurrent(component, gridConfig).bind(function (focused) { 7101 return gridConfig.execute(component, simulatedEvent, focused); 7102 }); 7103 }; 7104 var doMove = function (cycle) { 7105 return function (element, focused, gridConfig, gridState) { 7106 return locateVisible(element, focused, gridConfig.selector).bind(function (identified) { 7107 return cycle(identified.candidates, identified.index, gridState.getNumRows().getOr(gridConfig.initSize.numRows), gridState.getNumColumns().getOr(gridConfig.initSize.numColumns)); 7108 }); 7109 }; 7110 }; 7111 var handleTab = function (_component, _simulatedEvent, gridConfig) { 7112 return gridConfig.captureTab ? Optional.some(true) : Optional.none(); 7113 }; 7114 var doEscape = function (component, simulatedEvent, gridConfig) { 7115 return gridConfig.onEscape(component, simulatedEvent); 7116 }; 7117 var moveLeft = doMove(cycleLeft); 7118 var moveRight = doMove(cycleRight); 7119 var moveNorth = doMove(cycleUp); 7120 var moveSouth = doMove(cycleDown); 7121 var getKeydownRules$1 = constant([ 7122 rule(inSet(LEFT), west$2(moveLeft, moveRight)), 7123 rule(inSet(RIGHT), east$2(moveLeft, moveRight)), 7124 rule(inSet(UP), north$2(moveNorth)), 7125 rule(inSet(DOWN), south$2(moveSouth)), 7126 rule(and([ 7127 isShift, 7128 inSet(TAB) 7129 ]), handleTab), 7130 rule(and([ 7131 isNotShift, 7132 inSet(TAB) 7133 ]), handleTab), 7134 rule(inSet(ESCAPE), doEscape), 7135 rule(inSet(SPACE.concat(ENTER)), execute$2) 7136 ]); 7137 var getKeyupRules$1 = constant([rule(inSet(SPACE), stopEventForFirefox)]); 7138 var FlatgridType = typical(schema$5, flatgrid, getKeydownRules$1, getKeyupRules$1, function () { 7139 return Optional.some(focusIn); 7140 }); 7141 7142 var horizontal = function (container, selector, current, delta) { 7143 var isDisabledButton = function (candidate) { 7144 return name(candidate) === 'button' && get$3(candidate, 'disabled') === 'disabled'; 7145 }; 7146 var tryCycle = function (initial, index, candidates) { 7147 var newIndex = cycleBy(index, delta, 0, candidates.length - 1); 7148 if (newIndex === initial) { 7149 return Optional.none(); 7150 } else { 7151 return isDisabledButton(candidates[newIndex]) ? tryCycle(initial, newIndex, candidates) : Optional.from(candidates[newIndex]); 7152 } 7153 }; 7154 return locateVisible(container, current, selector).bind(function (identified) { 7155 var index = identified.index; 7156 var candidates = identified.candidates; 7157 return tryCycle(index, index, candidates); 7158 }); 7159 }; 7160 7161 var schema$6 = [ 7162 strict$1('selector'), 7163 defaulted$1('getInitial', Optional.none), 7164 defaulted$1('execute', defaultExecute), 7165 onKeyboardHandler('onEscape'), 7166 defaulted$1('executeOnMove', false), 7167 defaulted$1('allowVertical', true) 7168 ]; 7169 var findCurrent$1 = function (component, flowConfig) { 7170 return flowConfig.focusManager.get(component).bind(function (elem) { 7171 return closest$3(elem, flowConfig.selector); 7172 }); 7173 }; 7174 var execute$3 = function (component, simulatedEvent, flowConfig) { 7175 return findCurrent$1(component, flowConfig).bind(function (focused) { 7176 return flowConfig.execute(component, simulatedEvent, focused); 7177 }); 7178 }; 7179 var focusIn$1 = function (component, flowConfig, _state) { 7180 flowConfig.getInitial(component).orThunk(function () { 7181 return descendant$1(component.element, flowConfig.selector); 7182 }).each(function (first) { 7183 flowConfig.focusManager.set(component, first); 7184 }); 7185 }; 7186 var moveLeft$1 = function (element, focused, info) { 7187 return horizontal(element, info.selector, focused, -1); 7188 }; 7189 var moveRight$1 = function (element, focused, info) { 7190 return horizontal(element, info.selector, focused, +1); 7191 }; 7192 var doMove$1 = function (movement) { 7193 return function (component, simulatedEvent, flowConfig, flowState) { 7194 return movement(component, simulatedEvent, flowConfig, flowState).bind(function () { 7195 return flowConfig.executeOnMove ? execute$3(component, simulatedEvent, flowConfig) : Optional.some(true); 7196 }); 7197 }; 7198 }; 7199 var doEscape$1 = function (component, simulatedEvent, flowConfig) { 7200 return flowConfig.onEscape(component, simulatedEvent); 7201 }; 7202 var getKeydownRules$2 = function (_component, _se, flowConfig, _flowState) { 7203 var westMovers = LEFT.concat(flowConfig.allowVertical ? UP : []); 7204 var eastMovers = RIGHT.concat(flowConfig.allowVertical ? DOWN : []); 7205 return [ 7206 rule(inSet(westMovers), doMove$1(west$2(moveLeft$1, moveRight$1))), 7207 rule(inSet(eastMovers), doMove$1(east$2(moveLeft$1, moveRight$1))), 7208 rule(inSet(ENTER), execute$3), 7209 rule(inSet(SPACE), execute$3), 7210 rule(inSet(ESCAPE), doEscape$1) 7211 ]; 7212 }; 7213 var getKeyupRules$2 = constant([rule(inSet(SPACE), stopEventForFirefox)]);
7214 var FlowType = typical(schema$6, NoState.init, getKeydownRules$2, getKeyupRules$2, function () { 7215 return Optional.some(focusIn$1); 7216 }); 7217 7218 var toCell = function (matrix, rowIndex, columnIndex) { 7219 return Optional.from(matrix[rowIndex]).bind(function (row) { 7220 return Optional.from(row[columnIndex]).map(function (cell) { 7221 return { 7222 rowIndex: rowIndex, 7223 columnIndex: columnIndex, 7224 cell: cell 7225 }; 7226 }); 7227 }); 7228 }; 7229 var cycleHorizontal$1 = function (matrix, rowIndex, startCol, deltaCol) { 7230 var row = matrix[rowIndex]; 7231 var colsInRow = row.length; 7232 var newColIndex = cycleBy(startCol, deltaCol, 0, colsInRow - 1); 7233 return toCell(matrix, rowIndex, newColIndex); 7234 }; 7235 var cycleVertical$1 = function (matrix, colIndex, startRow, deltaRow) { 7236 var nextRowIndex = cycleBy(startRow, deltaRow, 0, matrix.length - 1); 7237 var colsInNextRow = matrix[nextRowIndex].length; 7238 var nextColIndex = clamp(colIndex, 0, colsInNextRow - 1); 7239 return toCell(matrix, nextRowIndex, nextColIndex); 7240 }; 7241 var moveHorizontal = function (matrix, rowIndex, startCol, deltaCol) { 7242 var row = matrix[rowIndex]; 7243 var colsInRow = row.length; 7244 var newColIndex = clamp(startCol + deltaCol, 0, colsInRow - 1); 7245 return toCell(matrix, rowIndex, newColIndex); 7246 }; 7247 var moveVertical = function (matrix, colIndex, startRow, deltaRow) { 7248 var nextRowIndex = clamp(startRow + deltaRow, 0, matrix.length - 1); 7249 var colsInNextRow = matrix[nextRowIndex].length; 7250 var nextColIndex = clamp(colIndex, 0, colsInNextRow - 1); 7251 return toCell(matrix, nextRowIndex, nextColIndex); 7252 }; 7253 var cycleRight$1 = function (matrix, startRow, startCol) { 7254 return cycleHorizontal$1(matrix, startRow, startCol, +1); 7255 }; 7256 var cycleLeft$1 = function (matrix, startRow, startCol) { 7257 return cycleHorizontal$1(matrix, startRow, startCol, -1); 7258 }; 7259 var cycleUp$1 = function (matrix, startRow, startCol) { 7260 return cycleVertical$1(matrix, startCol, startRow, -1); 7261 }; 7262 var cycleDown$1 = function (matrix, startRow, startCol) { 7263 return cycleVertical$1(matrix, startCol, startRow, +1); 7264 }; 7265 var moveLeft$2 = function (matrix, startRow, startCol) { 7266 return moveHorizontal(matrix, startRow, startCol, -1); 7267 }; 7268 var moveRight$2 = function (matrix, startRow, startCol) { 7269 return moveHorizontal(matrix, startRow, startCol, +1); 7270 }; 7271 var moveUp = function (matrix, startRow, startCol) { 7272 return moveVertical(matrix, startCol, startRow, -1); 7273 }; 7274 var moveDown = function (matrix, startRow, startCol) { 7275 return moveVertical(matrix, startCol, startRow, +1); 7276 }; 7277 7278 var schema$7 = [ 7279 strictObjOf('selectors', [ 7280 strict$1('row'), 7281 strict$1('cell') 7282 ]), 7283 defaulted$1('cycles', true), 7284 defaulted$1('previousSelector', Optional.none), 7285 defaulted$1('execute', defaultExecute) 7286 ]; 7287 var focusIn$2 = function (component, matrixConfig, _state) { 7288 var focused = matrixConfig.previousSelector(component).orThunk(function () { 7289 var selectors = matrixConfig.selectors; 7290 return descendant$1(component.element, selectors.cell); 7291 }); 7292 focused.each(function (cell) { 7293 matrixConfig.focusManager.set(component, cell); 7294 }); 7295 }; 7296 var execute$4 = function (component, simulatedEvent, matrixConfig) { 7297 return search(component.element).bind(function (focused) { 7298 return matrixConfig.execute(component, simulatedEvent, focused); 7299 }); 7300 }; 7301 var toMatrix = function (rows, matrixConfig) { 7302 return map(rows, function (row) { 7303 return descendants(row, matrixConfig.selectors.cell); 7304 }); 7305 }; 7306 var doMove$2 = function (ifCycle, ifMove) { 7307 return function (element, focused, matrixConfig) { 7308 var move = matrixConfig.cycles ? ifCycle : ifMove; 7309 return closest$3(focused, matrixConfig.selectors.row).bind(function (inRow) { 7310 var cellsInRow = descendants(inRow, matrixConfig.selectors.cell); 7311 return findIndex$1(cellsInRow, focused).bind(function (colIndex) { 7312 var allRows = descendants(element, matrixConfig.selectors.row); 7313 return findIndex$1(allRows, inRow).bind(function (rowIndex) { 7314 var matrix = toMatrix(allRows, matrixConfig); 7315 return move(matrix, rowIndex, colIndex).map(function (next) { 7316 return next.cell; 7317 }); 7318 }); 7319 }); 7320 }); 7321 }; 7322 }; 7323 var moveLeft$3 = doMove$2(cycleLeft$1, moveLeft$2); 7324 var moveRight$3 = doMove$2(cycleRight$1, moveRight$2); 7325 var moveNorth$1 = doMove$2(cycleUp$1, moveUp); 7326 var moveSouth$1 = doMove$2(cycleDown$1, moveDown); 7327 var getKeydownRules$3 = constant([ 7328 rule(inSet(LEFT), west$2(moveLeft$3, moveRight$3)), 7329 rule(inSet(RIGHT), east$2(moveLeft$3, moveRight$3)), 7330 rule(inSet(UP), north$2(moveNorth$1)), 7331 rule(inSet(DOWN), south$2(moveSouth$1)), 7332 rule(inSet(SPACE.concat(ENTER)), execute$4) 7333 ]); 7334 var getKeyupRules$3 = constant([rule(inSet(SPACE), stopEventForFirefox)]);
7335 var MatrixType = typical(schema$7, NoState.init, getKeydownRules$3, getKeyupRules$3, function () { 7336 return Optional.some(focusIn$2); 7337 }); 7338 7339 var schema$8 = [ 7340 strict$1('selector'), 7341 defaulted$1('execute', defaultExecute), 7342 defaulted$1('moveOnTab', false) 7343 ]; 7344 var execute$5 = function (component, simulatedEvent, menuConfig) { 7345 return menuConfig.focusManager.get(component).bind(function (focused) { 7346 return menuConfig.execute(component, simulatedEvent, focused); 7347 }); 7348 }; 7349 var focusIn$3 = function (component, menuConfig, _state) { 7350 descendant$1(component.element, menuConfig.selector).each(function (first) { 7351 menuConfig.focusManager.set(component, first); 7352 }); 7353 }; 7354 var moveUp$1 = function (element, focused, info) { 7355 return horizontal(element, info.selector, focused, -1); 7356 }; 7357 var moveDown$1 = function (element, focused, info) { 7358 return horizontal(element, info.selector, focused, +1); 7359 }; 7360 var fireShiftTab = function (component, simulatedEvent, menuConfig, menuState) { 7361 return menuConfig.moveOnTab ? move(moveUp$1)(component, simulatedEvent, menuConfig, menuState) : Optional.none(); 7362 }; 7363 var fireTab = function (component, simulatedEvent, menuConfig, menuState) { 7364 return menuConfig.moveOnTab ? move(moveDown$1)(component, simulatedEvent, menuConfig, menuState) : Optional.none(); 7365 }; 7366 var getKeydownRules$4 = constant([ 7367 rule(inSet(UP), move(moveUp$1)), 7368 rule(inSet(DOWN), move(moveDown$1)), 7369 rule(and([ 7370 isShift, 7371 inSet(TAB) 7372 ]), fireShiftTab), 7373 rule(and([ 7374 isNotShift, 7375 inSet(TAB) 7376 ]), fireTab), 7377 rule(inSet(ENTER), execute$5), 7378 rule(inSet(SPACE), execute$5) 7379 ]); 7380 var getKeyupRules$4 = constant([rule(inSet(SPACE), stopEventForFirefox)]); 7381 var MenuType = typical(schema$8, NoState.init, getKeydownRules$4, getKeyupRules$4, function () { 7382 return Optional.some(focusIn$3); 7383 }); 7384 7385 var schema$9 = [ 7386 onKeyboardHandler('onSpace'), 7387 onKeyboardHandler('onEnter'), 7388 onKeyboardHandler('onShiftEnter'), 7389 onKeyboardHandler('onLeft'), 7390 onKeyboardHandler('onRight'), 7391 onKeyboardHandler('onTab'), 7392 onKeyboardHandler('onShiftTab'), 7393 onKeyboardHandler('onUp'), 7394 onKeyboardHandler('onDown'), 7395 onKeyboardHandler('onEscape'), 7396 defaulted$1('stopSpaceKeyup', false), 7397 option('focusIn') 7398 ]; 7399 var getKeydownRules$5 = function (component, simulatedEvent, specialInfo) { 7400 return [ 7401 rule(inSet(SPACE), specialInfo.onSpace), 7402 rule(and([ 7403 isNotShift, 7404 inSet(ENTER) 7405 ]), specialInfo.onEnter), 7406 rule(and([ 7407 isShift, 7408 inSet(ENTER) 7409 ]), specialInfo.onShiftEnter), 7410 rule(and([ 7411 isShift, 7412 inSet(TAB) 7413 ]), specialInfo.onShiftTab), 7414 rule(and([ 7415 isNotShift, 7416 inSet(TAB) 7417 ]), specialInfo.onTab), 7418 rule(inSet(UP), specialInfo.onUp), 7419 rule(inSet(DOWN), specialInfo.onDown), 7420 rule(inSet(LEFT), specialInfo.onLeft), 7421 rule(inSet(RIGHT), specialInfo.onRight), 7422 rule(inSet(SPACE), specialInfo.onSpace), 7423 rule(inSet(ESCAPE), specialInfo.onEscape) 7424 ]; 7425 }; 7426 var getKeyupRules$5 = function (component, simulatedEvent, specialInfo) { 7427 return specialInfo.stopSpaceKeyup ? [rule(inSet(SPACE), stopEventForFirefox)] : []; 7428 }; 7429 var SpecialType = typical(schema$9, NoState.init, getKeydownRules$5, getKeyupRules$5, function (specialInfo) { 7430 return specialInfo.focusIn; 7431 }); 7432 7433 var acyclic = AcyclicType.schema(); 7434 var cyclic = CyclicType.schema(); 7435 var flow = FlowType.schema(); 7436 var flatgrid$1 = FlatgridType.schema(); 7437 var matrix = MatrixType.schema(); 7438 var execution = ExecutionType.schema(); 7439 var menu = MenuType.schema(); 7440 var special = SpecialType.schema(); 7441 7442 var KeyboardBranches = /*#__PURE__*/Object.freeze({ 7443 __proto__: null, 7444 acyclic: acyclic, 7445 cyclic: cyclic, 7446 flow: flow, 7447 flatgrid: flatgrid$1, 7448 matrix: matrix, 7449 execution: execution, 7450 menu: menu, 7451 special: special 7452 }); 7453 7454 var isFlatgridState = function (keyState) { 7455 return hasNonNullableKey(keyState, 'setGridSize'); 7456 }; 7457 var Keying = createModes$1({ 7458 branchKey: 'mode', 7459 branches: KeyboardBranches, 7460 name: 'keying', 7461 active: { 7462 events: function (keyingConfig, keyingState) { 7463 var handler = keyingConfig.handler; 7464 return handler.toEvents(keyingConfig, keyingState); 7465 } 7466 }, 7467 apis: { 7468 focusIn: function (component, keyConfig, keyState) { 7469 keyConfig.sendFocusIn(keyConfig).fold(function () { 7470 component.getSystem().triggerFocus(component.element, component.element); 7471 }, function (sendFocusIn) { 7472 sendFocusIn(component, keyConfig, keyState); 7473 }); 7474 }, 7475 setGridSize: function (component, keyConfig, keyState, numRows, numColumns) { 7476 if (!isFlatgridState(keyState)) { 7477 console.error('Layout does not support setGridSize'); 7478 } else { 7479 keyState.setGridSize(numRows, numColumns); 7480 } 7481 } 7482 }, 7483 state: KeyingState 7484 }); 7485 7486 var set$5 = function (component, replaceConfig, replaceState, data) { 7487 preserve(function () { 7488 var newChildren = map(data, component.getSystem().build); 7489 replaceChildren(component, newChildren); 7490 }, component.element); 7491 }; 7492 var insert = function (component, replaceConfig, insertion, childSpec) { 7493 var child = component.getSystem().build(childSpec); 7494 attachWith(component, child, insertion); 7495 }; 7496 var append$2 = function (component, replaceConfig, replaceState, appendee) { 7497 insert(component, replaceConfig, append, appendee); 7498 }; 7499 var prepend$1 = function (component, replaceConfig, replaceState, prependee) { 7500 insert(component, replaceConfig, prepend, prependee); 7501 }; 7502 var remove$7 = function (component, replaceConfig, replaceState, removee) { 7503 var children = contents(component); 7504 var foundChild = find(children, function (child) { 7505 return eq$1(removee.element, child.element); 7506 }); 7507 foundChild.each(detach); 7508 }; 7509 var contents = function (component, _replaceConfig) { 7510 return component.components(); 7511 }; 7512 var replaceAt = function (component, replaceConfig, replaceState, replaceeIndex, replacer) { 7513 var children = contents(component); 7514 return Optional.from(children[replaceeIndex]).map(function (replacee) { 7515 remove$7(component, replaceConfig, replaceState, replacee); 7516 replacer.each(function (r) { 7517 insert(component, replaceConfig, function (p, c) { 7518 appendAt(p, c, replaceeIndex); 7519 }, r); 7520 }); 7521 return replacee; 7522 }); 7523 }; 7524 var replaceBy = function (component, replaceConfig, replaceState, replaceePred, replacer) { 7525 var children = contents(component); 7526 return findIndex(children, replaceePred).bind(function (replaceeIndex) { 7527 return replaceAt(component, replaceConfig, replaceState, replaceeIndex, replacer); 7528 }); 7529 }; 7530 7531 var ReplaceApis = /*#__PURE__*/Object.freeze({ 7532 __proto__: null, 7533 append: append$2, 7534 prepend: prepend$1, 7535 remove: remove$7, 7536 replaceAt: replaceAt, 7537 replaceBy: replaceBy, 7538 set: set$5,
7539 contents: contents 7540 }); 7541 7542 var Replacing = create$1({ 7543 fields: [], 7544 name: 'replacing', 7545 apis: ReplaceApis 7546 }); 7547 7548 var events$4 = function (name, eventHandlers) { 7549 var events = derive(eventHandlers); 7550 return create$1({ 7551 fields: [strict$1('enabled')], 7552 name: name, 7553 active: { events: constant(events) } 7554 }); 7555 }; 7556 var config = function (name, eventHandlers) { 7557 var me = events$4(name, eventHandlers); 7558 return { 7559 key: name, 7560 value: { 7561 config: {}, 7562 me: me, 7563 configAsRaw: constant({}), 7564 initialConfig: {}, 7565 state: NoState 7566 } 7567 }; 7568 }; 7569 7570 var focus$2 = function (component, focusConfig) { 7571 if (!focusConfig.ignore) { 7572 focus$1(component.element); 7573 focusConfig.onFocus(component); 7574 } 7575 }; 7576 var blur$1 = function (component, focusConfig) { 7577 if (!focusConfig.ignore) { 7578 blur(component.element); 7579 } 7580 }; 7581 var isFocused = function (component) { 7582 return hasFocus(component.element); 7583 }; 7584 7585 var FocusApis = /*#__PURE__*/Object.freeze({ 7586 __proto__: null, 7587 focus: focus$2, 7588 blur: blur$1, 7589 isFocused: isFocused 7590 }); 7591 7592 var exhibit$1 = function (base, focusConfig) { 7593 var mod = focusConfig.ignore ? {} : { attributes: { tabindex: '-1' } }; 7594 return nu$6(mod); 7595 }; 7596 var events$5 = function (focusConfig) { 7597 return derive([run(focus(), function (component, simulatedEvent) { 7598 focus$2(component, focusConfig); 7599 simulatedEvent.stop(); 7600 })].concat(focusConfig.stopMousedown ? [run(mousedown(), function (_, simulatedEvent) { 7601 simulatedEvent.event.prevent(); 7602 })] : [])); 7603 }; 7604 7605 var ActiveFocus = /*#__PURE__*/Object.freeze({ 7606 __proto__: null, 7607 exhibit: exhibit$1, 7608 events: events$5 7609 }); 7610 7611 var FocusSchema = [ 7612 onHandler('onFocus'), 7613 defaulted$1('stopMousedown', false), 7614 defaulted$1('ignore', false) 7615 ]; 7616 7617 var Focusing = create$1({ 7618 fields: FocusSchema, 7619 name: 'focusing', 7620 active: ActiveFocus, 7621 apis: FocusApis 7622 }); 7623 7624 var SetupBehaviourCellState = function (initialState) { 7625 var init = function () { 7626 var cell = Cell(initialState); 7627 var get = function () { 7628 return cell.get(); 7629 }; 7630 var set = function (newState) { 7631 return cell.set(newState); 7632 }; 7633 var clear = function () { 7634 return cell.set(initialState); 7635 }; 7636 var readState = function () { 7637 return cell.get(); 7638 }; 7639 return { 7640 get: get, 7641 set: set, 7642 clear: clear, 7643 readState: readState 7644 }; 7645 }; 7646 return { init: init }; 7647 }; 7648 7649 var updateAriaState = function (component, toggleConfig, toggleState) { 7650 var ariaInfo = toggleConfig.aria; 7651 ariaInfo.update(component, ariaInfo, toggleState.get()); 7652 }; 7653 var updateClass = function (component, toggleConfig, toggleState) { 7654 toggleConfig.toggleClass.each(function (toggleClass) { 7655 if (toggleState.get()) { 7656 add$2(component.element, toggleClass); 7657 } else { 7658 remove$4(component.element, toggleClass); 7659 } 7660 }); 7661 }; 7662 var toggle = function (component, toggleConfig, toggleState) { 7663 set$6(component, toggleConfig, toggleState, !toggleState.get()); 7664 }; 7665 var on$1 = function (component, toggleConfig, toggleState) { 7666 toggleState.set(true); 7667 updateClass(component, toggleConfig, toggleState); 7668 updateAriaState(component, toggleConfig, toggleState); 7669 }; 7670 var off = function (component, toggleConfig, toggleState) { 7671 toggleState.set(false); 7672 updateClass(component, toggleConfig, toggleState); 7673 updateAriaState(component, toggleConfig, toggleState); 7674 }; 7675 var set$6 = function (component, toggleConfig, toggleState, state) { 7676 var action = state ? on$1 : off; 7677 action(component, toggleConfig, toggleState); 7678 }; 7679 var isOn = function (component, toggleConfig, toggleState) { 7680 return toggleState.get(); 7681 }; 7682 var onLoad$4 = function (component, toggleConfig, toggleState) { 7683 set$6(component, toggleConfig, toggleState, toggleConfig.selected); 7684 }; 7685 7686 var ToggleApis = /*#__PURE__*/Object.freeze({ 7687 __proto__: null, 7688 onLoad: onLoad$4, 7689 toggle: toggle, 7690 isOn: isOn, 7691 on: on$1, 7692 off: off, 7693 set: set$6 7694 }); 7695 7696 var exhibit$2 = function () { 7697 return nu$6({}); 7698 }; 7699 var events$6 = function (toggleConfig, toggleState) { 7700 var execute = executeEvent(toggleConfig, toggleState, toggle); 7701 var load = loadEvent(toggleConfig, toggleState, onLoad$4); 7702 return derive(flatten([ 7703 toggleConfig.toggleOnExecute ? [execute] : [], 7704 [load] 7705 ])); 7706 }; 7707 7708 var ActiveToggle = /*#__PURE__*/Object.freeze({ 7709 __proto__: null, 7710 exhibit: exhibit$2, 7711 events: events$6 7712 }); 7713 7714 var updatePressed = function (component, ariaInfo, status) { 7715 set$1(component.element, 'aria-pressed', status); 7716 if (ariaInfo.syncWithExpanded) { 7717 updateExpanded(component, ariaInfo, status); 7718 } 7719 }; 7720 var updateSelected = function (component, ariaInfo, status) { 7721 set$1(component.element, 'aria-selected', status); 7722 }; 7723 var updateChecked = function (component, ariaInfo, status) { 7724 set$1(component.element, 'aria-checked', status); 7725 }; 7726 var updateExpanded = function (component, ariaInfo, status) { 7727 set$1(component.element, 'aria-expanded', status); 7728 }; 7729 7730 var ToggleSchema = [ 7731 defaulted$1('selected', false), 7732 option('toggleClass'), 7733 defaulted$1('toggleOnExecute', true), 7734 defaultedOf('aria', { mode: 'none' }, choose$1('mode', { 7735 pressed: [ 7736 defaulted$1('syncWithExpanded', false), 7737 output('update', updatePressed) 7738 ], 7739 checked: [output('update', updateChecked)], 7740 expanded: [output('update', updateExpanded)], 7741 selected: [output('update', updateSelected)], 7742 none: [output('update', noop)] 7743 })) 7744 ]; 7745 7746 var Toggling = create$1({ 7747 fields: ToggleSchema, 7748 name: 'toggling', 7749 active: ActiveToggle, 7750 apis: ToggleApis, 7751 state: SetupBehaviourCellState(false) 7752 }); 7753 7754 var pointerEvents = function () { 7755 var onClick = function (component, simulatedEvent) { 7756 simulatedEvent.stop(); 7757 emitExecute(component); 7758 }; 7759 return [ 7760 run(click(), onClick), 7761 run(tap(), onClick), 7762 cutter(touchstart()), 7763 cutter(mousedown()) 7764 ]; 7765 }; 7766 var events$7 = function (optAction) { 7767 var executeHandler = function (action) { 7768 return runOnExecute(function (component, simulatedEvent) { 7769 action(component); 7770 simulatedEvent.stop(); 7771 }); 7772 }; 7773 return derive(flatten([ 7774 optAction.map(executeHandler).toArray(), 7775 pointerEvents() 7776 ])); 7777 }; 7778 7779 var hoverEvent = 'alloy.item-hover'; 7780 var focusEvent = 'alloy.item-focus'; 7781 var onHover = function (item) { 7782 if (search(item.element).isNone() || Focusing.isFocused(item)) { 7783 if (!Focusing.isFocused(item)) { 7784 Focusing.focus(item); 7785 } 7786 emitWith(item, hoverEvent, { item: item }); 7787 } 7788 }; 7789 var onFocus = function (item) { 7790 emitWith(item, focusEvent, { item: item }); 7791 }; 7792 var hover = constant(hoverEvent); 7793 var focus$3 = constant(focusEvent); 7794 7795 var builder = function (detail) { 7796 return { 7797 dom: detail.dom, 7798 domModification: __assign(__assign({}, detail.domModification), { attributes: __assign(__assign(__assign({ 'role': detail.toggling.isSome() ? 'menuitemcheckbox' : 'menuitem' }, detail.domModification.attributes), { 'aria-haspopup': detail.hasSubmenu }), detail.hasSubmenu ? { 'aria-expanded': false } : {}) }), 7799 behaviours: SketchBehaviours.augment(detail.itemBehaviours, [ 7800 detail.toggling.fold(Toggling.revoke, function (tConfig) { 7801 return Toggling.config(__assign({ aria: { mode: 'checked' } }, tConfig)); 7802 }), 7803 Focusing.config({ 7804 ignore: detail.ignoreFocus, 7805 stopMousedown: detail.ignoreFocus, 7806 onFocus: function (component) { 7807 onFocus(component); 7808 } 7809 }), 7810 Keying.config({ mode: 'execution' }), 7811 Representing.config({ 7812 store: { 7813 mode: 'memory', 7814 initialValue: detail.data 7815 } 7816 }), 7817 config('item-type-events', __spreadArrays(pointerEvents(), [ 7818 run(mouseover(), onHover), 7819 run(focusItem(), Focusing.focus) 7820 ])) 7821 ]), 7822 components: detail.components, 7823 eventOrder: detail.eventOrder 7824 }; 7825 }; 7826 var schema$a = [
7827 strict$1('data'), 7828 strict$1('components'), 7829 strict$1('dom'), 7830 defaulted$1('hasSubmenu', false), 7831 option('toggling'), 7832 SketchBehaviours.field('itemBehaviours', [ 7833 Toggling, 7834 Focusing, 7835 Keying, 7836 Representing 7837 ]), 7838 defaulted$1('ignoreFocus', false), 7839 defaulted$1('domModification', {}), 7840 output('builder', builder), 7841 defaulted$1('eventOrder', {}) 7842 ]; 7843 7844 var builder$1 = function (detail) { 7845 return { 7846 dom: detail.dom, 7847 components: detail.components, 7848 events: derive([stopper(focusItem())]) 7849 }; 7850 }; 7851 var schema$b = [ 7852 strict$1('dom'), 7853 strict$1('components'), 7854 output('builder', builder$1) 7855 ]; 7856 7857 var owner$2 = constant('item-widget'); 7858 var parts = constant([required({ 7859 name: 'widget', 7860 overrides: function (detail) { 7861 return { 7862 behaviours: derive$1([Representing.config({ 7863 store: { 7864 mode: 'manual', 7865 getValue: function (_component) { 7866 return detail.data; 7867 }, 7868 setValue: noop 7869 } 7870 })]) 7871 }; 7872 } 7873 })]); 7874 7875 var builder$2 = function (detail) { 7876 var subs = substitutes(owner$2(), detail, parts()); 7877 var components$1 = components(owner$2(), detail, subs.internals()); 7878 var focusWidget = function (component) { 7879 return getPart(component, detail, 'widget').map(function (widget) { 7880 Keying.focusIn(widget); 7881 return widget; 7882 }); 7883 }; 7884 var onHorizontalArrow = function (component, simulatedEvent) { 7885 return inside(simulatedEvent.event.target) ? Optional.none() : function () { 7886 if (detail.autofocus) { 7887 simulatedEvent.setSource(component.element); 7888 return Optional.none(); 7889 } else { 7890 return Optional.none(); 7891 } 7892 }(); 7893 }; 7894 return { 7895 dom: detail.dom, 7896 components: components$1, 7897 domModification: detail.domModification, 7898 events: derive([ 7899 runOnExecute(function (component, simulatedEvent) { 7900 focusWidget(component).each(function (_widget) { 7901 simulatedEvent.stop(); 7902 }); 7903 }), 7904 run(mouseover(), onHover), 7905 run(focusItem(), function (component, _simulatedEvent) { 7906 if (detail.autofocus) { 7907 focusWidget(component); 7908 } else { 7909 Focusing.focus(component); 7910 } 7911 }) 7912 ]), 7913 behaviours: SketchBehaviours.augment(detail.widgetBehaviours, [ 7914 Representing.config({ 7915 store: { 7916 mode: 'memory', 7917 initialValue: detail.data 7918 } 7919 }), 7920 Focusing.config({ 7921 ignore: detail.ignoreFocus, 7922 onFocus: function (component) { 7923 onFocus(component); 7924 } 7925 }), 7926 Keying.config({ 7927 mode: 'special', 7928 focusIn: detail.autofocus ? function (component) { 7929 focusWidget(component); 7930 } : revoke(), 7931 onLeft: onHorizontalArrow, 7932 onRight: onHorizontalArrow, 7933 onEscape: function (component, simulatedEvent) { 7934 if (!Focusing.isFocused(component) && !detail.autofocus) { 7935 Focusing.focus(component); 7936 return Optional.some(true); 7937 } else if (detail.autofocus) { 7938 simulatedEvent.setSource(component.element); 7939 return Optional.none(); 7940 } else { 7941 return Optional.none(); 7942 } 7943 } 7944 }) 7945 ]) 7946 }; 7947 }; 7948 var schema$c = [ 7949 strict$1('uid'), 7950 strict$1('data'), 7951 strict$1('components'), 7952 strict$1('dom'), 7953 defaulted$1('autofocus', false), 7954 defaulted$1('ignoreFocus', false), 7955 SketchBehaviours.field('widgetBehaviours', [ 7956 Representing, 7957 Focusing, 7958 Keying 7959 ]), 7960 defaulted$1('domModification', {}), 7961 defaultUidsSchema(parts()), 7962 output('builder', builder$2) 7963 ]; 7964 7965 var itemSchema$1 = choose$1('type', { 7966 widget: schema$c, 7967 item: schema$a,
7968 separator: schema$b 7969 }); 7970 var configureGrid = function (detail, movementInfo) { 7971 return { 7972 mode: 'flatgrid', 7973 selector: '.' + detail.markers.item, 7974 initSize: { 7975 numColumns: movementInfo.initSize.numColumns, 7976 numRows: movementInfo.initSize.numRows 7977 }, 7978 focusManager: detail.focusManager 7979 }; 7980 }; 7981 var configureMatrix = function (detail, movementInfo) { 7982 return { 7983 mode: 'matrix', 7984 selectors: { 7985 row: movementInfo.rowSelector, 7986 cell: '.' + detail.markers.item 7987 }, 7988 focusManager: detail.focusManager 7989 }; 7990 }; 7991 var configureMenu = function (detail, movementInfo) { 7992 return { 7993 mode: 'menu', 7994 selector: '.' + detail.markers.item, 7995 moveOnTab: movementInfo.moveOnTab, 7996 focusManager: detail.focusManager 7997 }; 7998 }; 7999 var parts$1 = constant([group({ 8000 factory: { 8001 sketch: function (spec) { 8002 var itemInfo = asRawOrDie('menu.spec item', itemSchema$1, spec); 8003 return itemInfo.builder(itemInfo); 8004 } 8005 }, 8006 name: 'items', 8007 unit: 'item', 8008 defaults: function (detail, u) { 8009 return u.hasOwnProperty('uid') ? u : __assign(__assign({}, u), { uid: generate$2('item') }); 8010 }, 8011 overrides: function (detail, u) { 8012 return { 8013 type: u.type, 8014 ignoreFocus: detail.fakeFocus, 8015 domModification: { classes: [detail.markers.item] } 8016 }; 8017 } 8018 })]); 8019 var schema$d = constant([ 8020 strict$1('value'), 8021 strict$1('items'), 8022 strict$1('dom'), 8023 strict$1('components'), 8024 defaulted$1('eventOrder', {}), 8025 field$1('menuBehaviours', [ 8026 Highlighting, 8027 Representing, 8028 Composing, 8029 Keying 8030 ]), 8031 defaultedOf('movement', { 8032 mode: 'menu', 8033 moveOnTab: true 8034 }, choose$1('mode', { 8035 grid: [ 8036 initSize(), 8037 output('config', configureGrid) 8038 ], 8039 matrix: [ 8040 output('config', configureMatrix), 8041 strict$1('rowSelector') 8042 ], 8043 menu: [ 8044 defaulted$1('moveOnTab', true), 8045 output('config', configureMenu) 8046 ] 8047 })), 8048 itemMarkers(), 8049 defaulted$1('fakeFocus', false), 8050 defaulted$1('focusManager', dom()), 8051 onHandler('onHighlight') 8052 ]); 8053 8054 var focus$4 = constant('alloy.menu-focus'); 8055 8056 var make$1 = function (detail, components, _spec, _externals) { 8057 return { 8058 uid: detail.uid, 8059 dom: detail.dom, 8060 markers: detail.markers, 8061 behaviours: augment(detail.menuBehaviours, [ 8062 Highlighting.config({ 8063 highlightClass: detail.markers.selectedItem, 8064 itemClass: detail.markers.item, 8065 onHighlight: detail.onHighlight 8066 }), 8067 Representing.config({ 8068 store: { 8069 mode: 'memory', 8070 initialValue: detail.value 8071 } 8072 }), 8073 Composing.config({ find: Optional.some }), 8074 Keying.config(detail.movement.config(detail, detail.movement)) 8075 ]), 8076 events: derive([ 8077 run(focus$3(), function (menu, simulatedEvent) { 8078 var event = simulatedEvent.event; 8079 menu.getSystem().getByDom(event.target).each(function (item) { 8080 Highlighting.highlight(menu, item); 8081 simulatedEvent.stop(); 8082 emitWith(menu, focus$4(), { 8083 menu: menu, 8084 item: item 8085 }); 8086 }); 8087 }), 8088 run(hover(), function (menu, simulatedEvent) { 8089 var item = simulatedEvent.event.item; 8090 Highlighting.highlight(menu, item); 8091 }) 8092 ]), 8093 components: components, 8094 eventOrder: detail.eventOrder, 8095 domModification: { attributes: { role: 'menu' } } 8096 }; 8097 }; 8098 8099 var Menu = composite$1({ 8100 name: 'Menu', 8101 configFields: schema$d(), 8102 partFields: parts$1(), 8103 factory: make$1 8104 }); 8105 8106 var transpose = function (obj) { 8107 return tupleMap(obj, function (v, k) { 8108 return { 8109 k: v, 8110 v: k 8111 }; 8112 }); 8113 }; 8114 var trace = function (items, byItem, byMenu, finish) { 8115 return get$1(byMenu, finish).bind(function (triggerItem) { 8116 return get$1(items, triggerItem).bind(function (triggerMenu) { 8117 var rest = trace(items, byItem, byMenu, triggerMenu); 8118 return Optional.some([triggerMenu].concat(rest)); 8119 }); 8120 }).getOr([]); 8121 }; 8122 var generate$5 = function (menus, expansions) { 8123 var items = {}; 8124 each$1(menus, function (menuItems, menu) { 8125 each(menuItems, function (item) { 8126 items[item] = menu; 8127 }); 8128 }); 8129 var byItem = expansions; 8130 var byMenu = transpose(expansions); 8131 var menuPaths = map$2(byMenu, function (_triggerItem, submenu) { 8132 return [submenu].concat(trace(items, byItem, byMenu, submenu)); 8133 }); 8134 return map$2(items, function (menu) { 8135 return get$1(menuPaths, menu).getOr([menu]); 8136 }); 8137 }; 8138 8139 var init$3 = function () { 8140 var expansions = Cell({}); 8141 var menus = Cell({}); 8142 var paths = Cell({}); 8143 var primary = Cell(Optional.none()); 8144 var directory = Cell({}); 8145 var clear = function () { 8146 expansions.set({}); 8147 menus.set({}); 8148 paths.set({}); 8149 primary.set(Optional.none()); 8150 }; 8151 var isClear = function () { 8152 return primary.get().isNone(); 8153 }; 8154 var setMenuBuilt = function (menuName, built) { 8155 var _a; 8156 menus.set(__assign(__assign({}, menus.get()), (_a = {}, _a[menuName] = { 8157 type: 'prepared', 8158 menu: built 8159 }, _a))); 8160 }; 8161 var setContents = function (sPrimary, sMenus, sExpansions, dir) { 8162 primary.set(Optional.some(sPrimary)); 8163 expansions.set(sExpansions); 8164 menus.set(sMenus); 8165 directory.set(dir); 8166 var sPaths = generate$5(dir, sExpansions); 8167 paths.set(sPaths); 8168 }; 8169 var getTriggeringItem = function (menuValue) { 8170 return find$1(expansions.get(), function (v, _k) { 8171 return v === menuValue; 8172 }); 8173 }; 8174 var getTriggerData = function (menuValue, getItemByValue, path) { 8175 return getPreparedMenu(menuValue).bind(function (menu) { 8176 return getTriggeringItem(menuValue).bind(function (triggeringItemValue) { 8177 return getItemByValue(triggeringItemValue).map(function (triggeredItem) { 8178 return { 8179 triggeredMenu: menu, 8180 triggeringItem: triggeredItem, 8181 triggeringPath: path 8182 }; 8183 }); 8184 }); 8185 }); 8186 };
8187 var getTriggeringPath = function (itemValue, getItemByValue) { 8188 var extraPath = filter(lookupItem(itemValue).toArray(), function (menuValue) { 8189 return getPreparedMenu(menuValue).isSome(); 8190 }); 8191 return get$1(paths.get(), itemValue).bind(function (path) { 8192 var revPath = reverse(extraPath.concat(path)); 8193 var triggers = bind(revPath, function (menuValue, menuIndex) { 8194 return getTriggerData(menuValue, getItemByValue, revPath.slice(0, menuIndex + 1)).fold(function () { 8195 return primary.get().is(menuValue) ? [] : [Optional.none()]; 8196 }, function (data) { 8197 return [Optional.some(data)]; 8198 }); 8199 }); 8200 return sequence(triggers); 8201 }); 8202 }; 8203 var expand = function (itemValue) { 8204 return get$1(expansions.get(), itemValue).map(function (menu) { 8205 var current = get$1(paths.get(), itemValue).getOr([]); 8206 return [menu].concat(current); 8207 }); 8208 }; 8209 var collapse = function (itemValue) { 8210 return get$1(paths.get(), itemValue).bind(function (path) { 8211 return path.length > 1 ? Optional.some(path.slice(1)) : Optional.none(); 8212 }); 8213 }; 8214 var refresh = function (itemValue) { 8215 return get$1(paths.get(), itemValue); 8216 }; 8217 var getPreparedMenu = function (menuValue) { 8218 return lookupMenu(menuValue).bind(extractPreparedMenu); 8219 }; 8220 var lookupMenu = function (menuValue) { 8221 return get$1(menus.get(), menuValue); 8222 }; 8223 var lookupItem = function (itemValue) { 8224 return get$1(expansions.get(), itemValue); 8225 }; 8226 var otherMenus = function (path) { 8227 var menuValues = directory.get(); 8228 return difference(keys(menuValues), path); 8229 }; 8230 var getPrimary = function () { 8231 return primary.get().bind(getPreparedMenu); 8232 }; 8233 var getMenus = function () { 8234 return menus.get(); 8235 }; 8236 return { 8237 setMenuBuilt: setMenuBuilt, 8238 setContents: setContents, 8239 expand: expand, 8240 refresh: refresh, 8241 collapse: collapse, 8242 lookupMenu: lookupMenu, 8243 lookupItem: lookupItem, 8244 otherMenus: otherMenus, 8245 getPrimary: getPrimary, 8246 getMenus: getMenus, 8247 clear: clear, 8248 isClear: isClear, 8249 getTriggeringPath: getTriggeringPath 8250 }; 8251 }; 8252 var extractPreparedMenu = function (prep) { 8253 return prep.type === 'prepared' ? Optional.some(prep.menu) : Optional.none(); 8254 }; 8255 var LayeredState = { 8256 init: init$3, 8257 extractPreparedMenu: extractPreparedMenu 8258 }; 8259 8260 var make$2 = function (detail, _rawUiSpec) { 8261 var submenuParentItems = Cell(Optional.none()); 8262 var buildMenus = function (container, primaryName, menus) { 8263 return map$2(menus, function (spec, name) { 8264 var makeSketch = function () { 8265 return Menu.sketch(__assign(__assign({}, spec), { 8266 value: name, 8267 markers: detail.markers, 8268 fakeFocus: detail.fakeFocus, 8269 onHighlight: detail.onHighlight, 8270 focusManager: detail.fakeFocus ? highlights() : dom() 8271 })); 8272 }; 8273 return name === primaryName ? { 8274 type: 'prepared', 8275 menu: container.getSystem().build(makeSketch()) 8276 } : { 8277 type: 'notbuilt', 8278 nbMenu: makeSketch 8279 }; 8280 }); 8281 }; 8282 var layeredState = LayeredState.init(); 8283 var setup = function (container) { 8284 var componentMap = buildMenus(container, detail.data.primary, detail.data.menus); 8285 var directory = toDirectory(); 8286 layeredState.setContents(detail.data.primary, componentMap, detail.data.expansions, directory); 8287 return layeredState.getPrimary(); 8288 }; 8289 var getItemValue = function (item) { 8290 return Representing.getValue(item).value; 8291 }; 8292 var getItemByValue = function (_container, menus, itemValue) { 8293 return findMap(menus, function (menu) { 8294 if (!menu.getSystem().isConnected()) { 8295 return Optional.none(); 8296 } 8297 var candidates = Highlighting.getCandidates(menu); 8298 return find(candidates, function (c) {
8299 return getItemValue(c) === itemValue; 8300 }); 8301 }); 8302 }; 8303 var toDirectory = function (_container) { 8304 return map$2(detail.data.menus, function (data, _menuName) { 8305 return bind(data.items, function (item) { 8306 return item.type === 'separator' ? [] : [item.data.value]; 8307 }); 8308 }); 8309 }; 8310 var setActiveMenu = function (container, menu) { 8311 Highlighting.highlight(container, menu); 8312 Highlighting.getHighlighted(menu).orThunk(function () { 8313 return Highlighting.getFirst(menu); 8314 }).each(function (item) { 8315 dispatch(container, item.element, focusItem()); 8316 }); 8317 }; 8318 var getMenus = function (state, menuValues) { 8319 return cat(map(menuValues, function (mv) { 8320 return state.lookupMenu(mv).bind(function (prep) { 8321 return prep.type === 'prepared' ? Optional.some(prep.menu) : Optional.none(); 8322 }); 8323 })); 8324 }; 8325 var closeOthers = function (container, state, path) { 8326 var others = getMenus(state, state.otherMenus(path)); 8327 each(others, function (o) { 8328 remove$5(o.element, [detail.markers.backgroundMenu]); 8329 if (!detail.stayInDom) { 8330 Replacing.remove(container, o); 8331 } 8332 }); 8333 }; 8334 var getSubmenuParents = function (container) { 8335 return submenuParentItems.get().getOrThunk(function () { 8336 var r = {}; 8337 var items = descendants(container.element, '.' + detail.markers.item); 8338 var parentItems = filter(items, function (i) { 8339 return get$3(i, 'aria-haspopup') === 'true'; 8340 }); 8341 each(parentItems, function (i) { 8342 container.getSystem().getByDom(i).each(function (itemComp) {
8343 var key = getItemValue(itemComp); 8344 r[key] = itemComp; 8345 }); 8346 }); 8347 submenuParentItems.set(Optional.some(r)); 8348 return r; 8349 }); 8350 }; 8351 var updateAriaExpansions = function (container, path) { 8352 var parentItems = getSubmenuParents(container); 8353 each$1(parentItems, function (v, k) { 8354 var expanded = contains(path, k); 8355 set$1(v.element, 'aria-expanded', expanded); 8356 }); 8357 }; 8358 var updateMenuPath = function (container, state, path) { 8359 return Optional.from(path[0]).bind(function (latestMenuName) { 8360 return state.lookupMenu(latestMenuName).bind(function (menuPrep) { 8361 if (menuPrep.type === 'notbuilt') { 8362 return Optional.none(); 8363 } else { 8364 var activeMenu = menuPrep.menu; 8365 var rest = getMenus(state, path.slice(1)); 8366 each(rest, function (r) { 8367 add$2(r.element, detail.markers.backgroundMenu); 8368 }); 8369 if (!inBody(activeMenu.element)) { 8370 Replacing.append(container, premade$1(activeMenu)); 8371 } 8372 remove$5(activeMenu.element, [detail.markers.backgroundMenu]);
8373 setActiveMenu(container, activeMenu); 8374 closeOthers(container, state, path); 8375 return Optional.some(activeMenu); 8376 } 8377 }); 8378 }); 8379 }; 8380 var ExpandHighlightDecision; 8381 (function (ExpandHighlightDecision) { 8382 ExpandHighlightDecision[ExpandHighlightDecision['HighlightSubmenu'] = 0] = 'HighlightSubmenu'; 8383 ExpandHighlightDecision[ExpandHighlightDecision['HighlightParent'] = 1] = 'HighlightParent'; 8384 }(ExpandHighlightDecision || (ExpandHighlightDecision = {}))); 8385 var buildIfRequired = function (container, menuName, menuPrep) { 8386 if (menuPrep.type === 'notbuilt') { 8387 var menu = container.getSystem().build(menuPrep.nbMenu()); 8388 layeredState.setMenuBuilt(menuName, menu); 8389 return menu; 8390 } else { 8391 return menuPrep.menu; 8392 } 8393 }; 8394 var expandRight = function (container, item, decision) { 8395 if (decision === void 0) { 8396 decision = ExpandHighlightDecision.HighlightSubmenu; 8397 } 8398 var value = getItemValue(item); 8399 return layeredState.expand(value).bind(function (path) { 8400 updateAriaExpansions(container, path); 8401 return Optional.from(path[0]).bind(function (menuName) { 8402 return layeredState.lookupMenu(menuName).bind(function (activeMenuPrep) { 8403 var activeMenu = buildIfRequired(container, menuName, activeMenuPrep); 8404 if (!inBody(activeMenu.element)) { 8405 Replacing.append(container, premade$1(activeMenu)); 8406 } 8407 detail.onOpenSubmenu(container, item, activeMenu, reverse(path)); 8408 if (decision === ExpandHighlightDecision.HighlightSubmenu) { 8409 Highlighting.highlightFirst(activeMenu); 8410 return updateMenuPath(container, layeredState, path); 8411 } else { 8412 Highlighting.dehighlightAll(activeMenu); 8413 return Optional.some(item); 8414 } 8415 }); 8416 }); 8417 }); 8418 }; 8419 var collapseLeft = function (container, item) { 8420 var value = getItemValue(item); 8421 return layeredState.collapse(value).bind(function (path) { 8422 updateAriaExpansions(container, path); 8423 return updateMenuPath(container, layeredState, path).map(function (activeMenu) { 8424 detail.onCollapseMenu(container, item, activeMenu); 8425 return activeMenu; 8426 }); 8427 }); 8428 }; 8429 var updateView = function (container, item) { 8430 var value = getItemValue(item); 8431 return layeredState.refresh(value).bind(function (path) { 8432 updateAriaExpansions(container, path); 8433 return updateMenuPath(container, layeredState, path); 8434 }); 8435 }; 8436 var onRight = function (container, item) { 8437 return inside(item.element) ? Optional.none() : expandRight(container, item, ExpandHighlightDecision.HighlightSubmenu); 8438 }; 8439 var onLeft = function (container, item) { 8440 return inside(item.element) ? Optional.none() : collapseLeft(container, item); 8441 }; 8442 var onEscape = function (container, item) { 8443 return collapseLeft(container, item).orThunk(function () { 8444 return detail.onEscape(container, item).map(function () { 8445 return container; 8446 }); 8447 }); 8448 }; 8449 var keyOnItem = function (f) { 8450 return function (container, simulatedEvent) { 8451 return closest$3(simulatedEvent.getSource(), '.' + detail.markers.item).bind(function (target) { 8452 return container.getSystem().getByDom(target).toOptional().bind(function (item) { 8453 return f(container, item).map(always); 8454 }); 8455 }); 8456 }; 8457 }; 8458 var events = derive([ 8459 run(focus$4(), function (sandbox, simulatedEvent) { 8460 var item = simulatedEvent.event.item; 8461 layeredState.lookupItem(getItemValue(item)).each(function () { 8462 var menu = simulatedEvent.event.menu; 8463 Highlighting.highlight(sandbox, menu); 8464 var value = getItemValue(simulatedEvent.event.item); 8465 layeredState.refresh(value).each(function (path) { 8466 return closeOthers(sandbox, layeredState, path); 8467 }); 8468 }); 8469 }), 8470 runOnExecute(function (component, simulatedEvent) { 8471 var target = simulatedEvent.event.target; 8472 component.getSystem().getByDom(target).each(function (item) {
8473 var itemValue = getItemValue(item); 8474 if (itemValue.indexOf('collapse-item') === 0) { 8475 collapseLeft(component, item); 8476 } 8477 expandRight(component, item, ExpandHighlightDecision.HighlightSubmenu).fold(function () { 8478 detail.onExecute(component, item); 8479 }, noop); 8480 }); 8481 }), 8482 runOnAttached(function (container, _simulatedEvent) { 8483 setup(container).each(function (primary) { 8484 Replacing.append(container, premade$1(primary)); 8485 detail.onOpenMenu(container, primary); 8486 if (detail.highlightImmediately) { 8487 setActiveMenu(container, primary); 8488 } 8489 }); 8490 }) 8491 ].concat(detail.navigateOnHover ? [run(hover(), function (sandbox, simulatedEvent) { 8492 var item = simulatedEvent.event.item; 8493 updateView(sandbox, item); 8494 expandRight(sandbox, item, ExpandHighlightDecision.HighlightParent); 8495 detail.onHover(sandbox, item); 8496 })] : [])); 8497 var getActiveItem = function (container) { 8498 return Highlighting.getHighlighted(container).bind(Highlighting.getHighlighted); 8499 }; 8500 var collapseMenuApi = function (container) { 8501 getActiveItem(container).each(function (currentItem) { 8502 collapseLeft(container, currentItem); 8503 }); 8504 }; 8505 var highlightPrimary = function (container) { 8506 layeredState.getPrimary().each(function (primary) {
8507 setActiveMenu(container, primary); 8508 }); 8509 }; 8510 var extractMenuFromContainer = function (container) { 8511 return Optional.from(container.components()[0]).filter(function (comp) { 8512 return get$3(comp.element, 'role') === 'menu'; 8513 }); 8514 }; 8515 var repositionMenus = function (container) { 8516 var maybeActivePrimary = layeredState.getPrimary().bind(function (primary) { 8517 return getActiveItem(container).bind(function (currentItem) { 8518 var itemValue = getItemValue(currentItem); 8519 var allMenus = values(layeredState.getMenus()); 8520 var preparedMenus = cat(map(allMenus, LayeredState.extractPreparedMenu)); 8521 return layeredState.getTriggeringPath(itemValue, function (v) { 8522 return getItemByValue(container, preparedMenus, v); 8523 }); 8524 }).map(function (triggeringPath) { 8525 return { 8526 primary: primary, 8527 triggeringPath: triggeringPath 8528 }; 8529 }); 8530 }); 8531 maybeActivePrimary.fold(function () { 8532 extractMenuFromContainer(container).each(function (primaryMenu) { 8533 detail.onRepositionMenu(container, primaryMenu, []); 8534 }); 8535 }, function (_a) { 8536 var primary = _a.primary, triggeringPath = _a.triggeringPath; 8537 detail.onRepositionMenu(container, primary, triggeringPath); 8538 }); 8539 }; 8540 var apis = { 8541 collapseMenu: collapseMenuApi, 8542 highlightPrimary: highlightPrimary, 8543 repositionMenus: repositionMenus 8544 }; 8545 return { 8546 uid: detail.uid, 8547 dom: detail.dom, 8548 markers: detail.markers, 8549 behaviours: augment(detail.tmenuBehaviours, [ 8550 Keying.config({ 8551 mode: 'special', 8552 onRight: keyOnItem(onRight), 8553 onLeft: keyOnItem(onLeft), 8554 onEscape: keyOnItem(onEscape), 8555 focusIn: function (container, _keyInfo) { 8556 layeredState.getPrimary().each(function (primary) { 8557 dispatch(container, primary.element, focusItem()); 8558 }); 8559 } 8560 }), 8561 Highlighting.config({ 8562 highlightClass: detail.markers.selectedMenu, 8563 itemClass: detail.markers.menu 8564 }), 8565 Composing.config({ 8566 find: function (container) { 8567 return Highlighting.getHighlighted(container); 8568 } 8569 }), 8570 Replacing.config({}) 8571 ]), 8572 eventOrder: detail.eventOrder, 8573 apis: apis, 8574 events: events 8575 }; 8576 }; 8577 var collapseItem = constant('collapse-item'); 8578 8579 var tieredData = function (primary, menus, expansions) { 8580 return { 8581 primary: primary, 8582 menus: menus, 8583 expansions: expansions 8584 }; 8585 }; 8586 var singleData = function (name, menu) { 8587 return { 8588 primary: name, 8589 menus: wrap$1(name, menu), 8590 expansions: {} 8591 }; 8592 }; 8593 var collapseItem$1 = function (text) { 8594 return { 8595 value: generate$1(collapseItem()), 8596 meta: { text: text } 8597 }; 8598 }; 8599 var tieredMenu = single$2({ 8600 name: 'TieredMenu', 8601 configFields: [ 8602 onStrictKeyboardHandler('onExecute'), 8603 onStrictKeyboardHandler('onEscape'), 8604 onStrictHandler('onOpenMenu'), 8605 onStrictHandler('onOpenSubmenu'), 8606 onHandler('onRepositionMenu'), 8607 onHandler('onCollapseMenu'), 8608 defaulted$1('highlightImmediately', true), 8609 strictObjOf('data', [ 8610 strict$1('primary'), 8611 strict$1('menus'), 8612 strict$1('expansions') 8613 ]), 8614 defaulted$1('fakeFocus', false), 8615 onHandler('onHighlight'), 8616 onHandler('onHover'), 8617 tieredMenuMarkers(), 8618 strict$1('dom'), 8619 defaulted$1('navigateOnHover', true), 8620 defaulted$1('stayInDom', false), 8621 field$1('tmenuBehaviours', [ 8622 Keying, 8623 Highlighting, 8624 Composing, 8625 Replacing 8626 ]), 8627 defaulted$1('eventOrder', {}) 8628 ], 8629 apis: { 8630 collapseMenu: function (apis, tmenu) { 8631 apis.collapseMenu(tmenu); 8632 }, 8633 highlightPrimary: function (apis, tmenu) { 8634 apis.highlightPrimary(tmenu); 8635 }, 8636 repositionMenus: function (apis, tmenu) { 8637 apis.repositionMenus(tmenu); 8638 } 8639 }, 8640 factory: make$2, 8641 extraApis: { 8642 tieredData: tieredData, 8643 singleData: singleData, 8644 collapseItem: collapseItem$1 8645 } 8646 }); 8647 8648 var makeMenu = function (detail, menuSandbox, anchor, menuSpec, getBounds) { 8649 var lazySink = function () { 8650 return detail.lazySink(menuSandbox); 8651 }; 8652 var layouts = menuSpec.type === 'horizontal' ? { 8653 layouts: { 8654 onLtr: function () { 8655 return belowOrAbove(); 8656 }, 8657 onRtl: function () { 8658 return belowOrAboveRtl(); 8659 } 8660 } 8661 } : {}; 8662 var isFirstTierSubmenu = function (triggeringPaths) { 8663 return triggeringPaths.length === 2; 8664 }; 8665 var getSubmenuLayouts = function (triggeringPaths) { 8666 return isFirstTierSubmenu(triggeringPaths) ? layouts : {}; 8667 }; 8668 return tieredMenu.sketch({ 8669 dom: { tag: 'div' }, 8670 data: menuSpec.data, 8671 markers: menuSpec.menu.markers, 8672 highlightImmediately: menuSpec.menu.highlightImmediately, 8673 onEscape: function () { 8674 Sandboxing.close(menuSandbox); 8675 detail.onEscape.map(function (handler) { 8676 return handler(menuSandbox); 8677 }); 8678 return Optional.some(true); 8679 }, 8680 onExecute: function () { 8681 return Optional.some(true); 8682 }, 8683 onOpenMenu: function (tmenu, menu) { 8684 Positioning.positionWithinBounds(lazySink().getOrDie(), anchor, menu, getBounds()); 8685 }, 8686 onOpenSubmenu: function (tmenu, item, submenu, triggeringPaths) { 8687 var sink = lazySink().getOrDie(); 8688 Positioning.position(sink, __assign({ 8689 anchor: 'submenu', 8690 item: item 8691 }, getSubmenuLayouts(triggeringPaths)), submenu); 8692 }, 8693 onRepositionMenu: function (tmenu, primaryMenu, submenuTriggers) { 8694 var sink = lazySink().getOrDie(); 8695 Positioning.positionWithinBounds(sink, anchor, primaryMenu, getBounds()); 8696 each(submenuTriggers, function (st) { 8697 var submenuLayouts = getSubmenuLayouts(st.triggeringPath); 8698 Positioning.position(sink, __assign({ 8699 anchor: 'submenu', 8700 item: st.triggeringItem 8701 }, submenuLayouts), st.triggeredMenu); 8702 }); 8703 } 8704 }); 8705 }; 8706 var factory = function (detail, spec) { 8707 var isPartOfRelated = function (sandbox, queryElem) { 8708 var related = detail.getRelated(sandbox); 8709 return related.exists(function (rel) { 8710 return isPartOf(rel, queryElem); 8711 }); 8712 }; 8713 var setContent = function (sandbox, thing) { 8714 Sandboxing.setContent(sandbox, thing); 8715 }; 8716 var showAt = function (sandbox, anchor, thing) { 8717 showWithin(sandbox, anchor, thing, Optional.none()); 8718 }; 8719 var showWithin = function (sandbox, anchor, thing, boxElement) { 8720 showWithinBounds(sandbox, anchor, thing, function () { 8721 return boxElement.map(function (elem) { 8722 return box(elem); 8723 }); 8724 }); 8725 }; 8726 var showWithinBounds = function (sandbox, anchor, thing, getBounds) { 8727 var sink = detail.lazySink(sandbox).getOrDie(); 8728 Sandboxing.openWhileCloaked(sandbox, thing, function () { 8729 return Positioning.positionWithinBounds(sink, anchor, sandbox, getBounds()); 8730 }); 8731 Representing.setValue(sandbox, Optional.some({ 8732 mode: 'position', 8733 anchor: anchor, 8734 getBounds: getBounds 8735 })); 8736 }; 8737 var showMenuAt = function (sandbox, anchor, menuSpec) { 8738 showMenuWithinBounds(sandbox, anchor, menuSpec, function () { 8739 return Optional.none(); 8740 }); 8741 }; 8742 var showMenuWithinBounds = function (sandbox, anchor, menuSpec, getBounds) { 8743 var menu = makeMenu(detail, sandbox, anchor, menuSpec, getBounds); 8744 Sandboxing.open(sandbox, menu); 8745 Representing.setValue(sandbox, Optional.some({ 8746 mode: 'menu', 8747 menu: menu 8748 })); 8749 }; 8750 var hide = function (sandbox) { 8751 if (Sandboxing.isOpen(sandbox)) { 8752 Representing.setValue(sandbox, Optional.none()); 8753 Sandboxing.close(sandbox); 8754 } 8755 }; 8756 var getContent = function (sandbox) { 8757 return Sandboxing.getState(sandbox); 8758 }; 8759 var reposition = function (sandbox) { 8760 if (Sandboxing.isOpen(sandbox)) { 8761 Representing.getValue(sandbox).each(function (state) { 8762 switch (state.mode) { 8763 case 'menu': 8764 Sandboxing.getState(sandbox).each(function (tmenu) { 8765 tieredMenu.repositionMenus(tmenu); 8766 }); 8767 break; 8768 case 'position': 8769 var sink = detail.lazySink(sandbox).getOrDie(); 8770 Positioning.positionWithinBounds(sink, state.anchor, sandbox, state.getBounds()); 8771 break; 8772 } 8773 }); 8774 } 8775 }; 8776 var apis = { 8777 setContent: setContent, 8778 showAt: showAt, 8779 showWithin: showWithin, 8780 showWithinBounds: showWithinBounds, 8781 showMenuAt: showMenuAt, 8782 showMenuWithinBounds: showMenuWithinBounds, 8783 hide: hide, 8784 getContent: getContent, 8785 reposition: reposition, 8786 isOpen: Sandboxing.isOpen 8787 }; 8788 return { 8789 uid: detail.uid, 8790 dom: detail.dom, 8791 behaviours: augment(detail.inlineBehaviours, [ 8792 Sandboxing.config({ 8793 isPartOf: function (sandbox, data, queryElem) { 8794 return isPartOf(data, queryElem) || isPartOfRelated(sandbox, queryElem); 8795 }, 8796 getAttachPoint: function (sandbox) { 8797 return detail.lazySink(sandbox).getOrDie(); 8798 }, 8799 onOpen: function (sandbox) { 8800 detail.onShow(sandbox); 8801 }, 8802 onClose: function (sandbox) { 8803 detail.onHide(sandbox); 8804 } 8805 }), 8806 Representing.config({ 8807 store: { 8808 mode: 'memory', 8809 initialValue: Optional.none() 8810 } 8811 }), 8812 Receiving.config({ 8813 channels: __assign(__assign({}, receivingChannel(__assign({ isExtraPart: spec.isExtraPart }, detail.fireDismissalEventInstead.map(function (fe) { 8814 return { fireEventInstead: { event: fe.event } }; 8815 }).getOr({})))), receivingChannel$1(__assign(__assign({}, detail.fireRepositionEventInstead.map(function (fe) { 8816 return { fireEventInstead: { event: fe.event } }; 8817 }).getOr({})), { doReposition: reposition }))) 8818 }) 8819 ]), 8820 eventOrder: detail.eventOrder, 8821 apis: apis 8822 }; 8823 }; 8824 var InlineView = single$2({ 8825 name: 'InlineView', 8826 configFields: [
8827 strict$1('lazySink'), 8828 onHandler('onShow'), 8829 onHandler('onHide'), 8830 optionFunction('onEscape'), 8831 field$1('inlineBehaviours', [ 8832 Sandboxing, 8833 Representing, 8834 Receiving 8835 ]), 8836 optionObjOf('fireDismissalEventInstead', [defaulted$1('event', dismissRequested())]), 8837 optionObjOf('fireRepositionEventInstead', [defaulted$1('event', repositionRequested())]), 8838 defaulted$1('getRelated', Optional.none), 8839 defaulted$1('isExtraPart', never), 8840 defaulted$1('eventOrder', Optional.none) 8841 ], 8842 factory: factory, 8843 apis: { 8844 showAt: function (apis, component, anchor, thing) { 8845 apis.showAt(component, anchor, thing); 8846 }, 8847 showWithin: function (apis, component, anchor, thing, boxElement) { 8848 apis.showWithin(component, anchor, thing, boxElement); 8849 }, 8850 showWithinBounds: function (apis, component, anchor, thing, bounds) { 8851 apis.showWithinBounds(component, anchor, thing, bounds); 8852 }, 8853 showMenuAt: function (apis, component, anchor, menuSpec) { 8854 apis.showMenuAt(component, anchor, menuSpec); 8855 }, 8856 showMenuWithinBounds: function (apis, component, anchor, menuSpec, bounds) { 8857 apis.showMenuWithinBounds(component, anchor, menuSpec, bounds); 8858 }, 8859 hide: function (apis, component) { 8860 apis.hide(component); 8861 }, 8862 isOpen: function (apis, component) { 8863 return apis.isOpen(component); 8864 }, 8865 getContent: function (apis, component) { 8866 return apis.getContent(component); 8867 }, 8868 setContent: function (apis, component, thing) { 8869 apis.setContent(component, thing); 8870 }, 8871 reposition: function (apis, component) { 8872 apis.reposition(component); 8873 } 8874 } 8875 }); 8876 8877 var westEdgeX$1 = function (anchor) { 8878 return anchor.x; 8879 }; 8880 var middleX$1 = function (anchor, element) { 8881 return anchor.x + anchor.width / 2 - element.width / 2; 8882 }; 8883 var eastEdgeX$1 = function (anchor, element) { 8884 return anchor.x + anchor.width - element.width; 8885 }; 8886 var northY$2 = function (anchor) { 8887 return anchor.y; 8888 }; 8889 var southY$2 = function (anchor, element) { 8890 return anchor.y + anchor.height - element.height; 8891 }; 8892 var southeast$3 = function (anchor, element, bubbles) { 8893 return nu$7(eastEdgeX$1(anchor, element), southY$2(anchor, element), bubbles.innerSoutheast(), northwest(), boundsRestriction(anchor, { 8894 right: 0, 8895 bottom: 3 8896 }), 'layout-inner-se'); 8897 }; 8898 var southwest$3 = function (anchor, element, bubbles) { 8899 return nu$7(westEdgeX$1(anchor), southY$2(anchor, element), bubbles.innerSouthwest(), northeast(), boundsRestriction(anchor, { 8900 left: 1, 8901 bottom: 3 8902 }), 'layout-inner-sw'); 8903 }; 8904 var northeast$3 = function (anchor, element, bubbles) { 8905 return nu$7(eastEdgeX$1(anchor, element), northY$2(anchor), bubbles.innerNortheast(), southwest(), boundsRestriction(anchor, { 8906 right: 0, 8907 top: 2 8908 }), 'layout-inner-ne'); 8909 }; 8910 var northwest$3 = function (anchor, element, bubbles) { 8911 return nu$7(westEdgeX$1(anchor), northY$2(anchor), bubbles.innerNorthwest(), southeast(), boundsRestriction(anchor, { 8912 left: 1, 8913 top: 2 8914 }), 'layout-inner-nw'); 8915 }; 8916 var north$3 = function (anchor, element, bubbles) { 8917 return nu$7(middleX$1(anchor, element), northY$2(anchor), bubbles.innerNorth(), south(), boundsRestriction(anchor, { top: 2 }), 'layout-inner-n'); 8918 }; 8919 var south$3 = function (anchor, element, bubbles) { 8920 return nu$7(middleX$1(anchor, element), southY$2(anchor, element), bubbles.innerSouth(), north(), boundsRestriction(anchor, { bottom: 3 }), 'layout-inner-s'); 8921 }; 8922 8923 var global$2 = tinymce.util.Tools.resolve('tinymce.util.Delay'); 8924 8925 var factory$1 = function (detail) { 8926 var events = events$7(detail.action); 8927 var tag = detail.dom.tag; 8928 var lookupAttr = function (attr) { 8929 return get$1(detail.dom, 'attributes').bind(function (attrs) { 8930 return get$1(attrs, attr); 8931 }); 8932 }; 8933 var getModAttributes = function () { 8934 if (tag === 'button') { 8935 var type = lookupAttr('type').getOr('button'); 8936 var roleAttrs = lookupAttr('role').map(function (role) { 8937 return { role: role }; 8938 }).getOr({}); 8939 return __assign({ type: type }, roleAttrs); 8940 } else { 8941 var role = lookupAttr('role').getOr('button'); 8942 return { role: role }; 8943 } 8944 }; 8945 return { 8946 uid: detail.uid, 8947 dom: detail.dom, 8948 components: detail.components, 8949 events: events, 8950 behaviours: SketchBehaviours.augment(detail.buttonBehaviours, [ 8951 Focusing.config({}), 8952 Keying.config({ 8953 mode: 'execution',
8954 useSpace: true, 8955 useEnter: true 8956 }) 8957 ]), 8958 domModification: { attributes: getModAttributes() }, 8959 eventOrder: detail.eventOrder 8960 }; 8961 }; 8962 var Button = single$2({ 8963 name: 'Button', 8964 factory: factory$1, 8965 configFields: [ 8966 defaulted$1('uid', undefined), 8967 strict$1('dom'), 8968 defaulted$1('components', []), 8969 SketchBehaviours.field('buttonBehaviours', [ 8970 Focusing, 8971 Keying 8972 ]), 8973 option('action'), 8974 option('role'), 8975 defaulted$1('eventOrder', {}) 8976 ] 8977 }); 8978 8979 var record = function (spec) { 8980 var uid = isSketchSpec(spec) && hasNonNullableKey(spec, 'uid') ? spec.uid : generate$2('memento'); 8981 var get = function (anyInSystem) { 8982 return anyInSystem.getSystem().getByUid(uid).getOrDie(); 8983 }; 8984 var getOpt = function (anyInSystem) { 8985 return anyInSystem.getSystem().getByUid(uid).toOptional(); 8986 }; 8987 var asSpec = function () { 8988 return __assign(__assign({}, spec), { uid: uid }); 8989 }; 8990 return { 8991 get: get, 8992 getOpt: getOpt, 8993 asSpec: asSpec 8994 }; 8995 }; 8996 8997 var defaultIcon = function (icons) { 8998 return Optional.from(icons()['temporary-placeholder']).getOr('!not found!'); 8999 }; 9000 var get$e = function (name, icons) { 9001 return Optional.from(icons()[name.toLowerCase()]).getOrThunk(function () { 9002 return defaultIcon(icons); 9003 }); 9004 }; 9005 var getOr = function (name, icons, fallback) { 9006 return Optional.from(icons()[name.toLowerCase()]).or(fallback).getOrThunk(function () { 9007 return defaultIcon(icons); 9008 }); 9009 }; 9010 var getFirst$1 = function (names, icons) { 9011 return findMap(names, function (name) { 9012 return Optional.from(icons()[name.toLowerCase()]); 9013 }).getOrThunk(function () { 9014 return defaultIcon(icons); 9015 }); 9016 }; 9017 9018 var notificationIconMap = { 9019 success: 'checkmark', 9020 error: 'warning', 9021 err: 'error', 9022 warning: 'warning', 9023 warn: 'warning', 9024 info: 'info' 9025 }; 9026 var factory$2 = function (detail) { 9027 var memBannerText = record({ 9028 dom: { 9029 tag: 'p', 9030 innerHtml: detail.translationProvider(detail.text) 9031 }, 9032 behaviours: derive$1([Replacing.config({})]) 9033 }); 9034 var renderPercentBar = function (percent) { 9035 return { 9036 dom: { 9037 tag: 'div', 9038 classes: ['tox-bar'], 9039 attributes: { style: 'width: ' + percent + '%' } 9040 } 9041 }; 9042 }; 9043 var renderPercentText = function (percent) { 9044 return { 9045 dom: { 9046 tag: 'div', 9047 classes: ['tox-text'], 9048 innerHtml: percent + '%' 9049 } 9050 }; 9051 }; 9052 var memBannerProgress = record({ 9053 dom: { 9054 tag: 'div', 9055 classes: detail.progress ? [ 9056 'tox-progress-bar', 9057 'tox-progress-indicator' 9058 ] : ['tox-progress-bar'] 9059 }, 9060 components: [ 9061 { 9062 dom: { 9063 tag: 'div', 9064 classes: ['tox-bar-container'] 9065 }, 9066 components: [renderPercentBar(0)] 9067 }, 9068 renderPercentText(0) 9069 ], 9070 behaviours: derive$1([Replacing.config({})]) 9071 }); 9072 var updateProgress = function (comp, percent) { 9073 if (comp.getSystem().isConnected()) { 9074 memBannerProgress.getOpt(comp).each(function (progress) { 9075 Replacing.set(progress, [ 9076 { 9077 dom: { 9078 tag: 'div', 9079 classes: ['tox-bar-container'] 9080 }, 9081 components: [renderPercentBar(percent)] 9082 }, 9083 renderPercentText(percent) 9084 ]); 9085 }); 9086 } 9087 }; 9088 var updateText = function (comp, text$1) { 9089 if (comp.getSystem().isConnected()) { 9090 var banner = memBannerText.get(comp); 9091 Replacing.set(banner, [text(text$1)]); 9092 } 9093 }; 9094 var apis = { 9095 updateProgress: updateProgress, 9096 updateText: updateText 9097 }; 9098 var iconChoices = flatten([ 9099 detail.icon.toArray(), 9100 detail.level.toArray(), 9101 detail.level.bind(function (level) { 9102 return Optional.from(notificationIconMap[level]); 9103 }).toArray() 9104 ]); 9105 var memButton = record(Button.sketch({ 9106 dom: { 9107 tag: 'button', 9108 classes: [ 9109 'tox-notification__dismiss', 9110 'tox-button', 9111 'tox-button--naked', 9112 'tox-button--icon' 9113 ] 9114 }, 9115 components: [{ 9116 dom: { 9117 tag: 'div', 9118 classes: ['tox-icon'], 9119 innerHtml: get$e('close', detail.iconProvider), 9120 attributes: { 'aria-label': detail.translationProvider('Close') } 9121 } 9122 }], 9123 action: function (comp) { 9124 detail.onAction(comp); 9125 } 9126 })); 9127 var components = [ 9128 { 9129 dom: { 9130 tag: 'div', 9131 classes: ['tox-notification__icon'], 9132 innerHtml: getFirst$1(iconChoices, detail.iconProvider) 9133 } 9134 }, 9135 { 9136 dom: { 9137 tag: 'div', 9138 classes: ['tox-notification__body'] 9139 }, 9140 components: [memBannerText.asSpec()], 9141 behaviours: derive$1([Replacing.config({})]) 9142 } 9143 ]; 9144 return { 9145 uid: detail.uid, 9146 dom: { 9147 tag: 'div', 9148 attributes: { role: 'alert' }, 9149 classes: detail.level.map(function (level) { 9150 return [ 9151 'tox-notification', 9152 'tox-notification--in', 9153 'tox-notification--' + level 9154 ]; 9155 }).getOr([ 9156 'tox-notification', 9157 'tox-notification--in' 9158 ]) 9159 }, 9160 behaviours: derive$1([ 9161 Focusing.config({}), 9162 config('notification-events', [run(focusin(), function (comp) { 9163 memButton.getOpt(comp).each(Focusing.focus); 9164 })]) 9165 ]),
9166 components: components.concat(detail.progress ? [memBannerProgress.asSpec()] : []).concat(!detail.closeButton ? [] : [memButton.asSpec()]), 9167 apis: apis 9168 }; 9169 }; 9170 var Notification = single$2({ 9171 name: 'Notification', 9172 factory: factory$2, 9173 configFields: [ 9174 option('level'), 9175 strict$1('progress'), 9176 strict$1('icon'), 9177 strict$1('onAction'), 9178 strict$1('text'), 9179 strict$1('iconProvider'), 9180 strict$1('translationProvider'), 9181 defaultedBoolean('closeButton', true) 9182 ], 9183 apis: { 9184 updateProgress: function (apis, comp, percent) { 9185 apis.updateProgress(comp, percent); 9186 }, 9187 updateText: function (apis, comp, text) { 9188 apis.updateText(comp, text); 9189 } 9190 } 9191 }); 9192 9193 function NotificationManagerImpl (editor, extras, uiMothership) { 9194 var backstage = extras.backstage; 9195 var getLayoutDirection = function (rel) { 9196 switch (rel) { 9197 case 'bc-bc': 9198 return south$3; 9199 case 'tc-tc': 9200 return north$3; 9201 case 'tc-bc': 9202 return north$1; 9203 case 'bc-tc': 9204 default: 9205 return south$1; 9206 } 9207 }; 9208 var prePositionNotifications = function (notifications) { 9209 each(notifications, function (notification) { 9210 return notification.moveTo(0, 0); 9211 }); 9212 }; 9213 var positionNotifications = function (notifications) { 9214 if (notifications.length > 0) { 9215 head(notifications).each(function (firstItem) { 9216 return firstItem.moveRel(null, 'banner'); 9217 }); 9218 each(notifications, function (notification, index) { 9219 if (index > 0) { 9220 notification.moveRel(notifications[index - 1].getEl(), 'bc-tc'); 9221 } 9222 }); 9223 } 9224 }; 9225 var reposition = function (notifications) { 9226 prePositionNotifications(notifications); 9227 positionNotifications(notifications); 9228 }; 9229 var open = function (settings, closeCallback) { 9230 var hideCloseButton = !settings.closeButton && settings.timeout && (settings.timeout > 0 || settings.timeout < 0); 9231 var close = function () { 9232 closeCallback(); 9233 InlineView.hide(notificationWrapper); 9234 }; 9235 var notification = build$1(Notification.sketch({ 9236 text: settings.text, 9237 level: contains([ 9238 'success', 9239 'error', 9240 'warning', 9241 'warn', 9242 'info' 9243 ], settings.type) ? settings.type : undefined, 9244 progress: settings.progressBar === true, 9245 icon: Optional.from(settings.icon), 9246 closeButton: !hideCloseButton, 9247 onAction: close, 9248 iconProvider: backstage.shared.providers.icons, 9249 translationProvider: backstage.shared.providers.translate 9250 })); 9251 var notificationWrapper = build$1(InlineView.sketch(__assign({ 9252 dom: { 9253 tag: 'div', 9254 classes: ['tox-notifications-container'] 9255 }, 9256 lazySink: extras.backstage.shared.getSink, 9257 fireDismissalEventInstead: {} 9258 }, backstage.shared.header.isPositionedAtTop() ? {} : { fireRepositionEventInstead: {} }))); 9259 uiMothership.add(notificationWrapper); 9260 if (settings.timeout > 0) { 9261 global$2.setTimeout(function () { 9262 close(); 9263 }, settings.timeout); 9264 } 9265 return { 9266 close: close, 9267 moveTo: function (x, y) { 9268 InlineView.showAt(notificationWrapper, { 9269 anchor: 'makeshift', 9270 x: x, 9271 y: y 9272 }, premade$1(notification)); 9273 }, 9274 moveRel: function (element, rel) { 9275 if (rel !== 'banner') { 9276 var layoutDirection_1 = getLayoutDirection(rel); 9277 var nodeAnchor = { 9278 anchor: 'node', 9279 root: body(), 9280 node: Optional.some(SugarElement.fromDom(element)), 9281 layouts: { 9282 onRtl: function () { 9283 return [layoutDirection_1]; 9284 }, 9285 onLtr: function () { 9286 return [layoutDirection_1]; 9287 } 9288 } 9289 }; 9290 InlineView.showAt(notificationWrapper, nodeAnchor, premade$1(notification)); 9291 } else { 9292 InlineView.showAt(notificationWrapper, extras.backstage.shared.anch
9292ors.banner(), premade$1(notification)); 9293 } 9294 }, 9295 text: function (nuText) { 9296 Notification.updateText(notification, nuText); 9297 }, 9298 settings: settings, 9299 getEl: function () { 9300 return notification.element.dom; 9301 }, 9302 progressBar: { 9303 value: function (percent) { 9304 Notification.updateProgress(notification, percent); 9305 } 9306 } 9307 }; 9308 }; 9309 var close = function (notification) { 9310 notification.close(); 9311 }; 9312 var getArgs = function (notification) { 9313 return notification.settings; 9314 }; 9315 return { 9316 open: open, 9317 close: close, 9318 reposition: reposition, 9319 getArgs: getArgs 9320 }; 9321 } 9322 9323 var first = function (fn, rate) { 9324 var timer = null; 9325 var cancel = function () { 9326 if (timer !== null) { 9327 clearTimeout(timer); 9328 timer = null; 9329 } 9330 }; 9331 var throttle = function () { 9332 var args = []; 9333 for (var _i = 0; _i < arguments.length; _i++) { 9334 args[_i] = arguments[_i]; 9335 } 9336 if (timer === null) { 9337 timer = setTimeout(function () { 9338 fn.apply(null, args); 9339 timer = null; 9340 }, rate); 9341 } 9342 }; 9343 return { 9344 cancel: cancel, 9345 throttle: throttle 9346 }; 9347 }; 9348 var last$2 = function (fn, rate) { 9349 var timer = null; 9350 var cancel = function () { 9351 if (timer !== null) { 9352 clearTimeout(timer); 9353 timer = null; 9354 } 9355 }; 9356 var throttle = function () { 9357 var args = []; 9358 for (var _i = 0; _i < arguments.length; _i++) { 9359 args[_i] = arguments[_i]; 9360 } 9361 if (timer !== null) { 9362 clearTimeout(timer); 9363 } 9364 timer = setTimeout(function () { 9365 fn.apply(null, args); 9366 timer = null; 9367 }, rate); 9368 }; 9369 return { 9370 cancel: cancel, 9371 throttle: throttle 9372 }; 9373 }; 9374 9375 var global$3 = tinymce.util.Tools.resolve('tinymce.dom.TextSeeker'); 9376 9377 var isBoundary = function (dom, node) { 9378 return dom.isBlock(node) || contains([ 9379 'BR', 9380 'IMG', 9381 'HR', 9382 'INPUT' 9383 ], node.nodeName) || dom.getContentEditable(node) === 'false'; 9384 }; 9385 var repeatLeft = function (dom, node, offset, process, rootNode) { 9386 var search = global$3(dom, function (node) { 9387 return isBoundary(dom, node); 9388 }); 9389 return Optional.from(search.backwards(node, offset, process, rootNode)); 9390 }; 9391 9392 var autocompleteSelector = '[data-mce-autocompleter]'; 9393 var create$4 = function (editor, range) { 9394 return detect$4(SugarElement.fromDom(editor.selection.getNode())).getOrThunk(function () { 9395 var wrapper = SugarElement.fromHtml('<span data-mce-autocompleter="1" data-mce-bogus="1"></span>', editor.getDoc()); 9396 append(wrapper, SugarElement.fromDom(range.extractContents())); 9397 range.insertNode(wrapper.dom); 9398 parent(wrapper).each(function (elm) { 9399 return elm.dom.normalize(); 9400 }); 9401 last$1(wrapper).map(function (last) { 9402 editor.selection.setCursorLocation(last.dom, getEnd(last)); 9403 }); 9404 return wrapper; 9405 }); 9406 }; 9407 var detect$4 = function (elm) { 9408 return closest$3(elm, autocompleteSelector); 9409 }; 9410 9411 var isValidTextRange = function (rng) { 9412 return rng.collapsed && rng.startContainer.nodeType === 3; 9413 }; 9414 var getText = function (rng) { 9415 return rng.toString().replace(/\u00A0/g, ' ').replace(/\uFEFF/g, ''); 9416 }; 9417 var isWhitespace = function (chr) { 9418 return chr !== '' && ' \xA0\f\n\r\t\x0B'.indexOf(chr) !== -1; 9419 }; 9420 9421 var stripTriggerChar = function (text, triggerCh) { 9422 return text.substring(triggerCh.length); 9423 }; 9424 var findChar = function (text, index, ch) { 9425 var i; 9426 for (i = index - 1; i >= 0; i--) { 9427 var char = text.charAt(i); 9428 if (isWhitespace(char)) { 9429 return Optional.none(); 9430 } 9431 if (char === ch) { 9432 break; 9433 } 9434 } 9435 return Optional.some(i); 9436 }; 9437 var findStart = function (dom, initRange, ch, minChars) { 9438 if (minChars === void 0) { 9439 minChars = 0; 9440 } 9441 if (!isValidTextRange(initRange)) { 9442 return Optional.none(); 9443 } 9444 var findTriggerChIndex = function (element, offset, text) { 9445 return findChar(text, offset, ch).getOr(offset); 9446 }; 9447 var root = dom.getParent(initRange.startContainer, dom.isBlock) || dom.getRoot(); 9448 return repeatLeft(dom, initRange.startContainer, initRange.startOffset, findTriggerChIndex, root).bind(function (spot) { 9449 var range = initRange.cloneRange(); 9450 range.setStart(spot.container, spot.offset); 9451 range.setEnd(initRange.endContainer, initRange.endOffset); 9452 if (range.collapsed) { 9453 return Optional.none(); 9454 } 9455 var text = getText(range); 9456 var triggerCharIndex = text.lastIndexOf(ch); 9457 if (triggerCharIndex !== 0 || stripTriggerChar(text, ch).length < minChars) { 9458 return Optional.none(); 9459 } else { 9460 return Optional.some({ 9461 text: stripTriggerChar(text, ch), 9462 range: range, 9463 triggerChar: ch 9464 }); 9465 } 9466 }); 9467 }; 9468 var getContext = function (dom, initRange, ch, minChars) { 9469 if (minChars === void 0) { 9470 minChars = 0; 9471 } 9472 return detect$4(SugarElement.fromDom(initRange.startContainer)).fold(function () { 9473 return findStart(dom, initRange, ch, minChars); 9474 }, function (elm) { 9475 var range = dom.createRng(); 9476 range.selectNode(elm.dom); 9477 var text = getText(range); 9478 return Optional.some({ 9479 range: range, 9480 text: stripTriggerChar(text, ch), 9481 triggerChar: ch 9482 }); 9483 }); 9484 }; 9485 9486 var setup = function (api, editor) {
9487 editor.on('keypress compositionend', api.onKeypress.throttle); 9488 editor.on('remove', api.onKeypress.cancel); 9489 var redirectKeyToItem = function (item, e) { 9490 emitWith(item, keydown(), { raw: e }); 9491 }; 9492 editor.on('keydown', function (e) { 9493 var getItem = function () { 9494 return api.getView().bind(Highlighting.getHighlighted); 9495 }; 9496 if (e.which === 8) { 9497 api.onKeypress.throttle(e); 9498 } 9499 if (api.isActive()) { 9500 if (e.which === 27) { 9501 api.cancelIfNecessary(); 9502 } 9503 if (api.isMenuOpen()) { 9504 if (e.which === 13) { 9505 getItem().each(emitExecute); 9506 e.preventDefault(); 9507 } else if (e.which === 40) { 9508 getItem().fold(function () { 9509 api.getView().each(Highlighting.highlightFirst); 9510 }, function (item) { 9511 redirectKeyToItem(item, e); 9512 }); 9513 e.preventDefault(); 9514 e.stopImmediatePropagation(); 9515 } else if (e.which === 37 || e.which === 38 || e.which === 39) { 9516 getItem().each(function (item) { 9517 redirectKeyToItem(item, e); 9518 e.preventDefault(); 9519 e.stopImmediatePropagation(); 9520 }); 9521 } 9522 } else { 9523 if (e.which === 13 || e.which === 38 || e.which === 40) { 9524 api.cancelIfNecessary(); 9525 } 9526 } 9527 } 9528 }); 9529 editor.on('NodeChange', function (e) { 9530 if (api.isActive() && !api.isProcessingAction() && detect$4(SugarElement.fromDom(e.element)).isNone()) { 9531 api.cancelIfNecessary(); 9532 } 9533 }); 9534 }; 9535 var AutocompleterEditorEvents = { setup: setup }; 9536 9537 var global$4 = tinymce.util.Tools.resolve('tinymce.util.Promise'); 9538 9539 var point$1 = function (container, offset) { 9540 return { 9541 container: container, 9542 offset: offset 9543 }; 9544 }; 9545 9546 var isText$1 = function (node) { 9547 return node.nodeType === TEXT; 9548 }; 9549 var isElement$1 = function (node) { 9550 return node.nodeType === ELEMENT; 9551 }; 9552 var toLast = function (node) { 9553 if (isText$1(node)) { 9554 return point$1(node, node.data.length); 9555 } else { 9556 var children = node.childNodes; 9557 return children.length > 0 ? toLast(children[children.length - 1]) : point$1(node, children.length); 9558 } 9559 }; 9560 var toLeaf = function (node, offset) { 9561 var children = node.childNodes; 9562 if (children.length > 0 && offset < children.length) { 9563 return toLeaf(children[offset], 0); 9564 } else if (children.length > 0 && isElement$1(node) && children.length === offset) { 9565 return toLast(children[children.length - 1]); 9566 } else { 9567 return point$1(node, offset); 9568 } 9569 }; 9570 9571 var isPreviousCharContent = function (dom, leaf) { 9572 return repeatLeft(dom, leaf.container, leaf.offset, function (element, offset) { 9573 return offset === 0 ? -1 : offset; 9574 }, dom.getRoot()).filter(function (spot) { 9575 var char = spot.container.data.charAt(spot.offset - 1); 9576 return !isWhitespace(char); 9577 }).isSome(); 9578 }; 9579 var isStartOfWord = function (dom) { 9580 return function (rng) { 9581 var leaf = toLeaf(rng.startContainer, rng.startOffset); 9582 return !isPreviousCharContent(dom, leaf); 9583 }; 9584 }; 9585 var getTriggerContext = function (dom, initRange, database) { 9586 return findMap(database.triggerChars, function (ch) { 9587 return getContext(dom, initRange, ch); 9588 }); 9589 }; 9590 var lookup = function (editor, getDatabase) { 9591 var database = getDatabase(); 9592 var rng = editor.selection.getRng(); 9593 return getTriggerContext(editor.dom, rng, database).bind(function (context) { 9594 return lookupWithContext(editor, getDatabase, context); 9595 }); 9596 }; 9597 var lookupWithContext = function (editor, getDatabase, context, fetchOptions) { 9598 if (fetchOptions === void 0) { 9599 fetchOptions = {}; 9600 } 9601 var database = getDatabase(); 9602 var rng = editor.selection.getRng(); 9603 var startText = rng.startContainer.nodeValue; 9604 var autocompleters = filter(database.lookupByChar(context.triggerChar), function (autocompleter) { 9605 return context.text.length >= autocompleter.minChars && autocompleter.matches.getOrThunk(function () { 9606 return isStartOfWord(editor.dom); 9607 })(context.range, startText, context.text); 9608 }); 9609 if (autocompleters.length === 0) { 9610 return Optional.none(); 9611 } 9612 var lookupData = global$4.all(map(autocompleters, function (ac) { 9613 var fetchResult = ac.fetch(context.text, ac.maxResults, fetchOptions); 9614 return fetchResult.then(function (results) { 9615 return { 9616 matchText: context.text, 9617 items: results, 9618 columns: ac.columns, 9619 onAction: ac.onAction, 9620 highlightOn: ac.highlightOn 9621 }; 9622 }); 9623 })); 9624 return Optional.some({ 9625 lookupData: lookupData, 9626 context: context 9627 }); 9628 }; 9629 9630 var separatorMenuItemSchema = objOf([
9631 strictString('type'), 9632 optionString('text') 9633 ]); 9634 var createSeparatorMenuItem = function (spec) { 9635 return asRaw('separatormenuitem', separatorMenuItemSchema, spec); 9636 }; 9637 9638 var autocompleterItemSchema = objOf([ 9639 defaulted$1('type', 'autocompleteitem'), 9640 defaulted$1('active', false), 9641 defaulted$1('disabled', false), 9642 defaulted$1('meta', {}), 9643 strictString('value'), 9644 optionString('text'), 9645 optionString('icon') 9646 ]); 9647 var autocompleterSchema = objOf([ 9648 strictString('type'), 9649 strictString('ch'), 9650 defaultedNumber('minChars', 1), 9651 defaulted$1('columns', 1), 9652 defaultedNumber('maxResults', 10), 9653 optionFunction('matches'), 9654 strictFunction('fetch'), 9655 strictFunction('onAction'), 9656 defaultedArrayOf('highlightOn', [], string) 9657 ]); 9658 var createSeparatorItem = function (spec) { 9659 return asRaw('Autocompleter.Separator', separatorMenuItemSchema, spec); 9660 }; 9661 var createAutocompleterItem = function (spec) { 9662 return asRaw('Autocompleter.Item', autocompleterItemSchema, spec); 9663 }; 9664 var createAutocompleter = function (spec) { 9665 return asRaw('Autocompleter', autocompleterSchema, spec); 9666 }; 9667 9668 var baseToolbarButtonFields = [ 9669 defaultedBoolean('disabled', false), 9670 optionString('tooltip'), 9671 optionString('icon'), 9672 optionString('text'), 9673 defaultedFunction('onSetup', function () { 9674 return noop; 9675 }) 9676 ]; 9677 var toolbarButtonSchema = objOf([ 9678 strictString('type'), 9679 strictFunction('onAction') 9680 ].concat(baseToolbarButtonFields)); 9681 var createToolbarButton = function (spec) { 9682 return asRaw('toolbarbutton', toolbarButtonSchema, spec); 9683 }; 9684 9685 var baseToolbarToggleButtonFields = [defaultedBoolean('active', false)].concat(baseToolbarButtonFields); 9686 var toggleButtonSchema = objOf(baseToolbarToggleButtonFields.concat([ 9687 strictString('type'), 9688 strictFunction('onAction') 9689 ])); 9690 var createToggleButton = function (spec) { 9691 return asRaw('ToggleButton', toggleButtonSchema, spec); 9692 }; 9693 9694 var contextBarFields = [ 9695 defaultedFunction('predicate', never), 9696 defaultedStringEnum('scope', 'node', [ 9697 'node', 9698 'editor' 9699 ]), 9700 defaultedStringEnum('position', 'selection', [ 9701 'node', 9702 'selection', 9703 'line' 9704 ]) 9705 ]; 9706 9707 var contextButtonFields = baseToolbarButtonFields.concat([ 9708 defaulted$1('type', 'contextformbutton'), 9709 defaulted$1('primary', false), 9710 strictFunction('onAction'), 9711 state$1('original', identity) 9712 ]); 9713 var contextToggleButtonFields = baseToolbarToggleButtonFields.concat([ 9714 defaulted$1('type', 'contextformbutton'), 9715 defaulted$1('primary', false), 9716 strictFunction('onAction'), 9717 state$1('original', identity) 9718 ]); 9719 var launchButtonFields = baseToolbarButtonFields.concat([defaulted$1('type', 'contextformbutton')]); 9720 var launchToggleButtonFields = baseToolbarToggleButtonFields.concat([defaulted$1('type', 'contextformtogglebutton')]); 9721 var toggleOrNormal = choose$1('type', { 9722 contextformbutton: contextButtonFields, 9723 contextformtogglebutton: contextToggleButtonFields 9724 }); 9725 var contextFormSchema = objOf([ 9726 defaulted$1('type', 'contextform'), 9727 defaultedFunction('initValue', function () { 9728 return ''; 9729 }), 9730 optionString('label'), 9731 strictArrayOf('commands', toggleOrNormal), 9732 optionOf('launch', choose$1('type', { 9733 contextformbutton: launchButtonFields, 9734 contextformtogglebutton: launchToggleButtonFields 9735 })) 9736 ].concat(contextBarFields)); 9737 var createContextForm = function (spec) { 9738 return asRaw('ContextForm', contextFormSchema, spec); 9739 }; 9740 9741 var contextToolbarSchema = objOf([ 9742 defaulted$1('type', 'contexttoolbar'), 9743 strictString('items') 9744 ].concat(contextBarFields)); 9745 var createContextToolbar = function (spec) { 9746 return asRaw('ContextToolbar', contextToolbarSchema, spec); 9747 }; 9748 9749 var stringArray = function (a) { 9750 var all = {}; 9751 each(a, function (key) { 9752 all[key] = {}; 9753 }); 9754 return keys(all); 9755 }; 9756 9757 var register = function (editor) { 9758 var popups = editor.ui.registry.getAll().popups; 9759 var dataset = map$2(popups, function (popup) { 9760 return createAutocompleter(popup).fold(function (err) { 9761 throw new Error(formatError(err)); 9762 }, function (x) { 9763 return x; 9764 }); 9765 }); 9766 var triggerChars = stringArray(mapToArray(dataset, function (v) { 9767 return v.ch; 9768 })); 9769 var datasetValues = values(dataset); 9770 var lookupByChar = function (ch) { 9771 return filter(datasetValues, function (dv) { 9772 return dv.ch === ch; 9773 }); 9774 }; 9775 return { 9776 dataset: dataset, 9777 triggerChars: triggerChars, 9778 lookupByChar: lookupByChar 9779 }; 9780 }; 9781 9782 var ItemResponse; 9783 (function (ItemResponse) { 9784 ItemResponse[ItemResponse['CLOSE_ON_EXECUTE'] = 0] = 'CLOSE_ON_EXECUTE'; 9785 ItemResponse[ItemResponse['BUBBLE_TO_SANDBOX'] = 1] = 'BUBBLE_TO_SANDBOX'; 9786 }(ItemResponse || (ItemResponse = {}))); 9787 var ItemResponse$1 = ItemResponse; 9788 9789 var navClass = 'tox-menu-nav__js'; 9790 var selectableClass = 'tox-collection__item'; 9791 var colorClass = 'tox-swatch'; 9792 var presetClasses = { 9793 normal: navClass, 9794 color: colorClass 9795 }; 9796 var tickedClass = 'tox-collection__item--enabled'; 9797 var groupHeadingClass = 'tox-collection__group-heading'; 9798 var iconClass = 'tox-collection__item-icon'; 9799 var textClass = 'tox-collection__item-label'; 9800 var accessoryClass = 'tox-collection__item-accessory'; 9801 var caretClass = 'tox-collection__item-caret'; 9802 var checkmarkClass = 'tox-collection__item-checkmark'; 9803 var activeClass = 'tox-collection__item--active'; 9804 var iconClassRtl = 'tox-collection__item-icon-rtl'; 9805 var containerClass = 'tox-collection__item-container'; 9806 var containerColumnClass = 'tox-collection__item-container--column'; 9807 var containerRowClass = 'tox-collection__item-container--row'; 9808 var containerAlignRightClass = 'tox-collection__item-container--align-right'; 9809 var containerAlignLeftClass = 'tox-collection__item-container--align-left'; 9810 var containerValignTopClass = 'tox-collection__item-container--valign-top'; 9811 var containerValignMiddleClass = 'tox-collection__item-container--valign-middle'; 9812 var containerValignBottomClass = 'tox-collection__item-container--valign-bottom'; 9813 var classForPreset = function (presets) { 9814 return get$1(presetClasses, presets).getOr(navClass); 9815 }; 9816 9817 var forMenu = function (presets) {
9818 if (presets === 'color') { 9819 return 'tox-swatches'; 9820 } else { 9821 return 'tox-menu'; 9822 } 9823 }; 9824 var classes = function (presets) { 9825 return { 9826 backgroundMenu: 'tox-background-menu', 9827 selectedMenu: 'tox-selected-menu', 9828 selectedItem: 'tox-collection__item--active', 9829 hasIcons: 'tox-menu--has-icons', 9830 menu: forMenu(presets), 9831 tieredMenu: 'tox-tiered-menu' 9832 }; 9833 }; 9834 9835 var markers$1 = function (presets) { 9836 var menuClasses = classes(presets); 9837 return { 9838 backgroundMenu: menuClasses.backgroundMenu, 9839 selectedMenu: menuClasses.selectedMenu, 9840 menu: menuClasses.menu, 9841 selectedItem: menuClasses.selectedItem, 9842 item: classForPreset(presets) 9843 }; 9844 }; 9845 var dom$1 = function (hasIcons, columns, presets) { 9846 var menuClasses = classes(presets); 9847 return { 9848 tag: 'div', 9849 classes: flatten([ 9850 [ 9851 menuClasses.menu, 9852 'tox-menu-' + columns + '-column' 9853 ], 9854 hasIcons ? [menuClasses.hasIcons] : [] 9855 ]) 9856 }; 9857 }; 9858 var components$1 = [Menu.parts.items({})]; 9859 var part = function (hasIcons, columns, presets) { 9860 var menuClasses = classes(presets); 9861 var d = { 9862 tag: 'div', 9863 classes: flatten([[menuClasses.tieredMenu]]) 9864 }; 9865 return { 9866 dom: d, 9867 markers: markers$1(presets) 9868 }; 9869 }; 9870 9871 var chunk$1 = function (rowDom, numColumns) { 9872 return function (items) { 9873 var chunks = chunk(items, numColumns); 9874 return map(chunks, function (c) { 9875 return { 9876 dom: rowDom, 9877 components: c 9878 }; 9879 }); 9880 }; 9881 }; 9882 var forSwatch = function (columns) { 9883 return { 9884 dom: { 9885 tag: 'div', 9886 classes: [ 9887 'tox-menu', 9888 'tox-swatches-menu' 9889 ] 9890 }, 9891 components: [{ 9892 dom: { 9893 tag: 'div', 9894 classes: ['tox-swatches'] 9895 }, 9896 components: [Menu.parts.items({ 9897 preprocess: columns !== 'auto' ? chunk$1({ 9898 tag: 'div', 9899 classes: ['tox-swatches__row'] 9900 }, columns) : identity 9901 })] 9902 }] 9903 }; 9904 }; 9905 var forToolbar = function (columns) { 9906 return { 9907 dom: { 9908 tag: 'div', 9909 classes: [ 9910 'tox-menu', 9911 'tox-collection', 9912 'tox-collection--toolbar', 9913 'tox-collection--toolbar-lg' 9914 ] 9915 }, 9916 components: [Menu.parts.items({ 9917 preprocess: chunk$1({ 9918 tag: 'div', 9919 classes: ['tox-collection__group'] 9920 }, columns) 9921 })] 9922 }; 9923 }; 9924 var preprocessCollection = function (items, isSeparator) { 9925 var allSplits = []; 9926 var currentSplit = []; 9927 each(items, function (item, i) { 9928 if (isSeparator(item, i)) { 9929 if (currentSplit.length > 0) { 9930 allSplits.push(currentSplit); 9931 } 9932 currentSplit = []; 9933 if (has(item.dom, 'innerHtml')) { 9934 currentSplit.push(item); 9935 } 9936 } else { 9937 currentSplit.push(item); 9938 } 9939 }); 9940 if (currentSplit.length > 0) { 9941 allSplits.push(currentSplit); 9942 } 9943 return map(allSplits, function (s) { 9944 return { 9945 dom: { 9946 tag: 'div', 9947 classes: ['tox-collection__group'] 9948 }, 9949 components: s 9950 }; 9951 }); 9952 }; 9953 var forCollection = function (columns, initItems, _hasIcons) { 9954 return { 9955 dom: { 9956 tag: 'div', 9957 classes: [ 9958 'tox-menu', 9959 'tox-collection' 9960 ].concat(columns === 1 ? ['tox-collection--list'] : ['tox-collection--grid']) 9961 }, 9962 components: [Menu.parts.items({ 9963 preprocess: function (items) { 9964 if (columns !== 'auto' && columns > 1) { 9965 return chunk$1({ 9966 tag: 'div', 9967 classes: ['tox-collection__group'] 9968 }, columns)(items); 9969 } else { 9970 return preprocessCollection(items, function (_item, i) { 9971 return initItems[i].type === 'separator'; 9972 }); 9973 } 9974 } 9975 })] 9976 }; 9977 }; 9978 var forHorizontalCollection = function (initItems, _hasIcons) { 9979 return { 9980 dom: { 9981 tag: 'div', 9982 classes: [ 9983 'tox-collection', 9984 'tox-collection--horizontal' 9985 ] 9986 }, 9987 components: [Menu.parts.items({ 9988 preprocess: function (items) { 9989 return preprocessCollection(items, function (_item, i) { 9990 return initItems[i].type === 'separator'; 9991 }); 9992 } 9993 })] 9994 }; 9995 }; 9996 9997 var menuHasIcons = function (xs) { 9998 return exists(xs, function (item) { 9999 return 'icon' in item && item.icon !== undefined; 10000 }); 10001 }; 10002 var handleError = function (error) { 10003 console.error(formatError(error)); 10004 console.log(error); 10005 return Optional.none(); 10006 }; 10007 var createHorizontalPartialMenuWithAlloyItems = function (value, _hasIcons, items, _columns, _presets) { 10008 var structure = forHorizontalCollection(items); 10009 return { 10010 value: value, 10011 dom: structure.dom, 10012 components: structure.components, 10013 items: items 10014 }; 10015 };
10016 var createPartialMenuWithAlloyItems = function (value, hasIcons, items, columns, presets) { 10017 if (presets === 'color') { 10018 var structure = forSwatch(columns); 10019 return { 10020 value: value, 10021 dom: structure.dom, 10022 components: structure.components, 10023 items: items 10024 }; 10025 } 10026 if (presets === 'normal' && columns === 'auto') { 10027 var structure = forCollection(columns, items); 10028 return { 10029 value: value, 10030 dom: structure.dom, 10031 components: structure.components, 10032 items: items 10033 }; 10034 } 10035 if (presets === 'normal' && columns === 1) { 10036 var structure = forCollection(1, items); 10037 return { 10038 value: value, 10039 dom: structure.dom, 10040 components: structure.components, 10041 items: items 10042 }; 10043 } 10044 if (presets === 'normal') { 10045 var structure = forCollection(columns, items); 10046 return { 10047 value: value, 10048 dom: structure.dom, 10049 components: structure.components, 10050 items: items 10051 }; 10052 } 10053 if (presets === 'listpreview' && columns !== 'auto') { 10054 var structure = forToolbar(columns); 10055 return { 10056 value: value, 10057 dom: structure.dom, 10058 components: structure.components, 10059 items: items 10060 }; 10061 } 10062 return { 10063 value: value, 10064 dom: dom$1(hasIcons, columns, presets), 10065 components: components$1, 10066 items: items 10067 }; 10068 }; 10069 10070 var cardImageFields = [ 10071 strictString('type'), 10072 strictString('src'), 10073 optionString('alt'), 10074 defaultedArrayOf('classes', [], string) 10075 ]; 10076 var cardImageSchema = objOf(cardImageFields); 10077 10078 var cardTextFields = [ 10079 strictString('type'), 10080 strictString('text'), 10081 optionString('name'), 10082 defaultedArrayOf('classes', ['tox-collection__item-label'], string) 10083 ]; 10084 var cardTextSchema = objOf(cardTextFields); 10085 10086 var itemSchema$2 = valueThunkOf(function () { 10087 return chooseProcessor('type', { 10088 cardimage: cardImageSchema, 10089 cardtext: cardTextSchema, 10090 cardcontainer: cardContainerSchema 10091 }); 10092 }); 10093 var cardContainerSchema = objOf([ 10094 strictString('type'), 10095 defaultedString('direction', 'horizontal'), 10096 defaultedString('align', 'left'), 10097 defaultedString('valign', 'middle'), 10098 strictArrayOf('items', itemSchema$2) 10099 ]); 10100 10101 var commonMenuItemFields = [ 10102 defaultedBoolean('disabled', false), 10103 optionString('text'), 10104 optionString('shortcut'), 10105 field('value', 'value', defaultedThunk(function () { 10106 return generate$1('menuitem-value'); 10107 }), anyValue$1()), 10108 defaulted$1('meta', {}) 10109 ]; 10110 10111 var cardMenuItemSchema = objOf([ 10112 strictString('type'), 10113 optionString('label'), 10114 strictArrayOf('items', itemSchema$2), 10115 defaultedFunction('onSetup', function () { 10116 return noop; 10117 }), 10118 defaultedFunction('onAction', noop) 10119 ].concat(commonMenuItemFields)); 10120 var createCardMenuItem = function (spec) { 10121 return asRaw('cardmenuitem', cardMenuItemSchema, spec); 10122 }; 10123 10124 var choiceMenuItemSchema = objOf([ 10125 strictString('type'), 10126 defaultedBoolean('active', false), 10127 optionString('icon') 10128 ].concat(commonMenuItemFields)); 10129 var createChoiceMenuItem = function (spec) { 10130 return asRaw('choicemenuitem', choiceMenuItemSchema, spec); 10131 }; 10132 10133 var fancyTypes = [ 10134 'inserttable', 10135 'colorswatch' 10136 ]; 10137 var fancyMenuItemSchema = objOf([ 10138 strictString('type'), 10139 strictStringEnum('fancytype', fancyTypes), 10140 defaultedFunction('onAction', noop) 10141 ]); 10142 var createFancyMenuItem = function (spec) { 10143 return asRaw('fancymenuitem', fancyMenuItemSchema, spec); 10144 }; 10145 10146 var menuItemSchema = objOf([ 10147 strictString('type'), 10148 defaultedFunction('onSetup', function () { 10149 return noop; 10150 }), 10151 defaultedFunction('onAction', noop), 10152 optionString('icon') 10153 ].concat(commonMenuItemFields)); 10154 var createMenuItem = function (spec) { 10155 return asRaw('menuitem', menuItemSchema, spec); 10156 }; 10157 10158 var nestedMenuItemSchema = objOf([
10159 strictString('type'), 10160 strictFunction('getSubmenuItems'), 10161 defaultedFunction('onSetup', function () { 10162 return noop; 10163 }), 10164 optionString('icon') 10165 ].concat(commonMenuItemFields)); 10166 var createNestedMenuItem = function (spec) { 10167 return asRaw('nestedmenuitem', nestedMenuItemSchema, spec); 10168 }; 10169 10170 var toggleMenuItemSchema = objOf([ 10171 strictString('type'), 10172 optionString('icon'), 10173 defaultedBoolean('active', false), 10174 defaultedFunction('onSetup', function () { 10175 return noop; 10176 }), 10177 strictFunction('onAction') 10178 ].concat(commonMenuItemFields)); 10179 var createToggleMenuItem = function (spec) { 10180 return asRaw('togglemenuitem', toggleMenuItemSchema, spec); 10181 }; 10182 10183 var detectSize = function (comp, margin, selectorClass) { 10184 var descendants$1 = descendants(comp.element, '.' + selectorClass); 10185 if (descendants$1.length > 0) { 10186 var columnLength = findIndex(descendants$1, function (c) { 10187 var thisTop = c.dom.getBoundingClientRect().top; 10188 var cTop = descendants$1[0].dom.getBoundingClientRect().top; 10189 return Math.abs(thisTop - cTop) > margin; 10190 }).getOr(descendants$1.length); 10191 return Optional.some({ 10192 numColumns: columnLength, 10193 numRows: Math.ceil(descendants$1.length / columnLength) 10194 }); 10195 } else { 10196 return Optional.none(); 10197 } 10198 }; 10199 10200 var namedEvents = function (name, handlers) { 10201 return derive$1([config(name, handlers)]); 10202 }; 10203 var unnamedEvents = function (handlers) { 10204 return namedEvents(generate$1('unnamed-events'), handlers); 10205 }; 10206 var SimpleBehaviours = { 10207 namedEvents: namedEvents, 10208 unnamedEvents: unnamedEvents 10209 }; 10210 10211 var ExclusivityChannel = generate$1('tooltip.exclusive'); 10212 var ShowTooltipEvent = generate$1('tooltip.show'); 10213 var HideTooltipEvent = generate$1('tooltip.hide'); 10214 10215 var hideAllExclusive = function (component, _tConfig, _tState) { 10216 component.getSystem().broadcastOn([ExclusivityChannel], {}); 10217 }; 10218 var setComponents = function (component, tConfig, tState, specs) { 10219 tState.getTooltip().each(function (tooltip) { 10220 if (tooltip.getSystem().isConnected()) { 10221 Replacing.set(tooltip, specs); 10222 } 10223 }); 10224 }; 10225 10226 var TooltippingApis = /*#__PURE__*/Object.freeze({ 10227 __proto__: null, 10228 hideAllExclusive: hideAllExclusive, 10229 setComponents: setComponents 10230 }); 10231 10232 var events$8 = function (tooltipConfig, state) { 10233 var hide = function (comp) { 10234 state.getTooltip().each(function (p) { 10235 detach(p); 10236 tooltipConfig.onHide(comp, p); 10237 state.clearTooltip(); 10238 }); 10239 state.clearTimer(); 10240 }; 10241 var show = function (comp) { 10242 if (!state.isShowing()) { 10243 hideAllExclusive(comp); 10244 var sink = tooltipConfig.lazySink(comp).getOrDie(); 10245 var popup = comp.getSystem().build({ 10246 dom: tooltipConfig.tooltipDom, 10247 components: tooltipConfig.tooltipComponents, 10248 events: derive(tooltipConfig.mode === 'normal' ? [ 10249 run(mouseover(), function (_) { 10250 emit(comp, ShowTooltipEvent); 10251 }), 10252 run(mouseout(), function (_) { 10253 emit(comp, HideTooltipEvent); 10254 }) 10255 ] : []), 10256 behaviours: derive$1([Replacing.config({})]) 10257 }); 10258 state.setTooltip(popup); 10259 attach$1(sink, popup); 10260 tooltipConfig.onShow(comp, popup); 10261 Positioning.position(sink, tooltipConfig.anchor(comp), popup); 10262 } 10263 }; 10264 return derive(flatten([ 10265 [ 10266 run(ShowTooltipEvent, function (comp) { 10267 state.resetTimer(function () { 10268 show(comp); 10269 }, tooltipConfig.delay); 10270 }), 10271 run(HideTooltipEvent, function (comp) { 10272 state.resetTimer(function () { 10273 hide(comp); 10274 }, tooltipConfig.delay); 10275 }), 10276 run(receive(), function (comp, message) { 10277 var receivingData = message; 10278 if (!receivingData.universal) { 10279 if (contains(receivingData.channels, ExclusivityChannel)) { 10280 hide(comp); 10281 } 10282 } 10283 }), 10284 runOnDetached(function (comp) { 10285 hide(comp); 10286 }) 10287 ], 10288 tooltipConfig.mode === 'normal' ? [ 10289 run(focusin(), function (comp) { 10290 emit(comp, ShowTooltipEvent); 10291 }), 10292 run(postBlur(), function (comp) { 10293 emit(comp, HideTooltipEvent); 10294 }), 10295 run(mouseover(), function (comp) { 10296 emit(comp, ShowTooltipEvent); 10297 }), 10298 run(mouseout(), function (comp) { 10299 emit(comp, HideTooltipEvent); 10300 }) 10301 ] : [ 10302 run(highlight(), function (comp, _se) { 10303 emit(comp, ShowTooltipEvent); 10304 }), 10305 run(dehighlight(), function (comp) { 10306 emit(comp, HideTooltipEvent); 10307 }) 10308 ] 10309 ])); 10310 }; 10311 10312 var ActiveTooltipping = /*#__PURE__*/Object.freeze({ 10313 __proto__: null, 10314 events: events$8 10315 }); 10316 10317 var TooltippingSchema = [
10318 strict$1('lazySink'), 10319 strict$1('tooltipDom'), 10320 defaulted$1('exclusive', true), 10321 defaulted$1('tooltipComponents', []), 10322 defaulted$1('delay', 300), 10323 defaultedStringEnum('mode', 'normal', [ 10324 'normal', 10325 'follow-highlight' 10326 ]), 10327 defaulted$1('anchor', function (comp) { 10328 return { 10329 anchor: 'hotspot', 10330 hotspot: comp, 10331 layouts: { 10332 onLtr: constant([ 10333 south$1, 10334 north$1, 10335 southeast$1, 10336 northeast$1, 10337 southwest$1, 10338 northwest$1 10339 ]), 10340 onRtl: constant([ 10341 south$1, 10342 north$1, 10343 southeast$1, 10344 northeast$1, 10345 southwest$1, 10346 northwest$1 10347 ]) 10348 } 10349 }; 10350 }), 10351 onHandler('onHide'), 10352 onHandler('onShow') 10353 ]; 10354 10355 var init$4 = function () { 10356 var timer = Cell(Optional.none()); 10357 var popup = Cell(Optional.none()); 10358 var getTooltip = function () { 10359 return popup.get(); 10360 }; 10361 var setTooltip = function (comp) { 10362 popup.set(Optional.some(comp)); 10363 }; 10364 var clearTooltip = function () { 10365 popup.set(Optional.none()); 10366 }; 10367 var clearTimer = function () { 10368 timer.get().each(function (t) { 10369 clearTimeout(t); 10370 }); 10371 }; 10372 var resetTimer = function (f, delay) { 10373 clearTimer(); 10374 timer.set(Optional.some(setTimeout(function () { 10375 f(); 10376 }, delay))); 10377 }; 10378 var isShowing = function () { 10379 return popup.get().isSome(); 10380 }; 10381 var readState = constant('not-implemented'); 10382 return nu$5({ 10383 getTooltip: getTooltip, 10384 isShowing: isShowing, 10385 setTooltip: setTooltip, 10386 clearTooltip: clearTooltip, 10387 clearTimer: clearTimer, 10388 resetTimer: resetTimer, 10389 readState: readState 10390 }); 10391 }; 10392 10393 var TooltippingState = /*#__PURE__*/Object.freeze({ 10394 __proto__: null, 10395 init: init$4 10396 }); 10397 10398 var Tooltipping = create$1({ 10399 fields: TooltippingSchema, 10400 name: 'tooltipping', 10401 active: ActiveTooltipping, 10402 state: TooltippingState, 10403 apis: TooltippingApis 10404 }); 10405 10406 var escape = function (text) { 10407 return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); 10408 }; 10409 10410 var global$5 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils'); 10411 10412 var global$6 = tinymce.util.Tools.resolve('tinymce.util.I18n'); 10413 10414 var nativeDisabled = [ 10415 'input', 10416 'button', 10417 'textarea', 10418 'select' 10419 ]; 10420 var onLoad$5 = function (component, disableConfig, disableState) { 10421 var f = disableConfig.disabled() ? disable : enable; 10422 f(component, disableConfig); 10423 }; 10424 var hasNative = function (component, config) { 10425 return config.useNative === true && contains(nativeDisabled, name(component.element)); 10426 }; 10427 var nativeIsDisabled = function (component) { 10428 return has$1(component.element, 'disabled'); 10429 }; 10430 var nativeDisable = function (component) { 10431 set$1(component.element, 'disabled', 'disabled'); 10432 }; 10433 var nativeEnable = function (component) { 10434 remove$1(component.element, 'disabled'); 10435 }; 10436 var ariaIsDisabled = function (component) { 10437 return get$3(component.element, 'aria-disabled') === 'true'; 10438 }; 10439 var ariaDisable = function (component) { 10440 set$1(component.element, 'aria-disabled', 'true'); 10441 }; 10442 var ariaEnable = function (component) { 10443 set$1(component.element, 'aria-disabled', 'false'); 10444 }; 10445 var disable = function (component, disableConfig, _disableState) { 10446 disableConfig.disableClass.each(function (disableClass) { 10447 add$2(component.element, disableClass); 10448 }); 10449 var f = hasNative(component, disableConfig) ? nativeDisable : ariaDisable; 10450 f(component); 10451 disableConfig.onDisabled(component); 10452 }; 10453 var enable = function (component, disableConfig, _disableState) { 10454 disableConfig.disableClass.each(function (disableClass) { 10455 remove$4(component.element, disableClass); 10456 }); 10457 var f = hasNative(component, disableConfig) ? nativeEnable : ariaEnable; 10458 f(component); 10459 disableConfig.onEnabled(component); 10460 }; 10461 var isDisabled = function (component, disableConfig) { 10462 return hasNative(component, disableConfig) ? nativeIsDisabled(component) : ariaIsDisabled(component); 10463 }; 10464 var set$7 = function (component, disableConfig, disableState, disabled) { 10465 var f = disabled ? disable : enable; 10466 f(component, disableConfig); 10467 }; 10468 10469 var DisableApis = /*#__PURE__*/Object.freeze({ 10470 __proto__: null, 10471 enable: enable, 10472 disable: disable, 10473 isDisabled: isDisabled, 10474 onLoad: onLoad$5, 10475 set: set$7 10476 }); 10477 10478 var exhibit$3 = function (base, disableConfig) { 10479 return nu$6({ classes: disableConfig.disabled() ? disableConfig.disableClass.toArray() : [] }); 10480 }; 10481 var events$9 = function (disableConfig, disableState) { 10482 return derive([ 10483 abort(execute(), function (component, _simulatedEvent) { 10484 return isDisabled(component, disableConfig); 10485 }), 10486 loadEvent(disableConfig, disableState, onLoad$5) 10487 ]); 10488 }; 10489 10490 var ActiveDisable = /*#__PURE__*/Object.freeze({ 10491 __proto__: null, 10492 exhibit: exhibit$3, 10493 events: events$9 10494 }); 10495 10496 var DisableSchema = [ 10497 defaultedFunction('disabled', never), 10498 defaulted$1('useNative', true), 10499 option('disableClass'), 10500 onHandler('onDisabled'), 10501 onHandler('onEnabled') 10502 ]; 10503 10504 var Disabling = create$1({ 10505 fields: DisableSchema, 10506 name: 'disabling', 10507 active: ActiveDisable, 10508 apis: DisableApis 10509 }); 10510 10511 var global$7 = tinymce.util.Tools.resolve('tinymce.EditorManager'); 10512 10513 var getSkinUrl = function (editor) { 10514 var skin = editor.getParam('skin'); 10515 var skinUrl = editor.getParam('skin_url'); 10516 if (skin !== false) { 10517 var skinName = skin ? skin : 'oxide'; 10518 if (skinUrl) { 10519 skinUrl = editor.documentBaseURI.toAbsolute(skinUrl); 10520 } else { 10521 skinUrl = global$7.baseURL + '/skins/ui/' + skinName; 10522 } 10523 } 10524 return skinUrl; 10525 }; 10526 var isReadOnly = function (editor) { 10527 return editor.getParam('readonly', false, 'boolean'); 10528 }; 10529 var isSkinDisabled = function (editor) { 10530 return editor.getParam('skin') === false; 10531 }; 10532 var getHeightSetting = function (editor) { 10533 return editor.getParam('height', Math.max(editor.getElement().offsetHeight, 200)); 10534 }; 10535 var getWidthSetting = function (editor) { 10536 return editor.getParam('width', global$5.DOM.getStyle(editor.getElement(), 'width')); 10537 }; 10538 var getMinWidthSetting = function (editor) { 10539 return Optional.from(editor.getParam('min_width')).filter(isNumber); 10540 }; 10541 var getMinHeightSetting = function (editor) { 10542 return Optional.from(editor.getParam('min_height')).filter(isNumber); 10543 }; 10544 var getMaxWidthSetting = function (editor) { 10545 return Optional.from(editor.getParam('max_width')).filter(isNumber); 10546 }; 10547 var getMaxHeightSetting = function (editor) { 10548 return Optional.from(editor.getParam('max_height')).filter(isNumber); 10549 }; 10550 var getUserStyleFormats = function (editor) { 10551 return Optional.from(editor.getParam('style_formats')).filter(isArray); 10552 }; 10553 var isMergeStyleFormats = function (editor) { 10554 return editor.getParam('style_formats_merge', false, 'boolean'); 10555 }; 10556 var getLineHeightFormats = function (editor) { 10557 return editor.getParam('lineheight_formats', '1 1.1 1.2 1.3 1.4 1.5 2', 'string').split(' '); 10558 }; 10559 var getRemovedMenuItems = function (editor) { 10560 return editor.getParam('removed_menuitems', ''); 10561 }; 10562 var isMenubarEnabled = function (editor) { 10563 return editor.getParam('menubar', true, 'boolean') !== false; 10564 }; 10565 var isToolbarEnabled = function (editor) { 10566 var toolbar = editor.getParam('toolbar', true); 10567 var isToolbarTrue = toolbar === true; 10568 var isToolbarString = isString(toolbar); 10569 var isToolbarObjectArray = isArray(toolbar) && toolbar.length > 0; 10570 return !isMultipleToolbars(editor) && (isToolbarObjectArray || isToolbarString || isToolbarTrue); 10571 }; 10572 var getMultipleToolbarsSetting = function (editor) { 10573 var toolbars = range(9, function (num) { 10574 return editor.getParam('toolbar' + (num + 1), false, 'string'); 10575 }); 10576 var toolbarArray = filter(toolbars, function (toolbar) { 10577 return typeof toolbar === 'string'; 10578 }); 10579 return toolbarArray.length > 0 ? Optional.some(toolbarArray) : Optional.none(); 10580 }; 10581 var isMultipleToolbars = function (editor) { 10582 return getMultipleToolbarsSetting(editor).fold(function () { 10583 var toolbar = editor.getParam('toolbar', [], 'string[]'); 10584 return toolbar.length > 0; 10585 }, always); 10586 }; 10587 var ToolbarMode; 10588 (function (ToolbarMode) { 10589 ToolbarMode['default'] = 'wrap'; 10590 ToolbarMode['floating'] = 'floating';
10591 ToolbarMode['sliding'] = 'sliding'; 10592 ToolbarMode['scrolling'] = 'scrolling'; 10593 }(ToolbarMode || (ToolbarMode = {}))); 10594 var getToolbarMode = function (editor) { 10595 return editor.getParam('toolbar_mode', '', 'string'); 10596 }; 10597 var ToolbarLocation; 10598 (function (ToolbarLocation) { 10599 ToolbarLocation['auto'] = 'auto'; 10600 ToolbarLocation['top'] = 'top'; 10601 ToolbarLocation['bottom'] = 'bottom'; 10602 }(ToolbarLocation || (ToolbarLocation = {}))); 10603 var getToolbarGroups = function (editor) { 10604 return editor.getParam('toolbar_groups', {}, 'object'); 10605 }; 10606 var getToolbarLocation = function (editor) { 10607 return editor.getParam('toolbar_location', ToolbarLocation.auto, 'string'); 10608 }; 10609 var isToolbarLocationBottom = function (editor) { 10610 return getToolbarLocation(editor) === ToolbarLocation.bottom; 10611 }; 10612 var fixedContainerSelector = function (editor) { 10613 return editor.getParam('fixed_toolbar_container', '', 'string'); 10614 }; 10615 var fixedToolbarContainerTarget = function (editor) { 10616 return editor.getParam('fixed_toolbar_container_target'); 10617 }; 10618 var isToolbarPersist = function (editor) { 10619 return editor.getParam('toolbar_persist', false, 'boolean'); 10620 }; 10621 var fixedContainerTarget = function (editor) { 10622 if (!editor.inline) { 10623 return Optional.none(); 10624 } 10625 var selector = fixedContainerSelector(editor); 10626 if (selector.length > 0) { 10627 return descendant$1(body(), selector); 10628 } 10629 var element = fixedToolbarContainerTarget(editor); 10630 if (isNonNullable(element)) { 10631 return Optional.some(SugarElement.fromDom(element)); 10632 } 10633 return Optional.none(); 10634 }; 10635 var useFixedContainer = function (editor) { 10636 return editor.inline && fixedContainerTarget(editor).isSome(); 10637 }; 10638 var getUiContainer = function (editor) { 10639 var fixedContainer = fixedContainerTarget(editor); 10640 return fixedContainer.getOrThunk(function () { 10641 return getContentContainer(getRootNode(SugarElement.fromDom(editor.getElement()))); 10642 }); 10643 }; 10644 var isDistractionFree = function (editor) { 10645 return editor.inline && !isMenubarEnabled(editor) && !isToolbarEnabled(editor) && !isMultipleToolbars(editor); 10646 }; 10647 var isStickyToolbar = function (editor) { 10648 var isStickyToolbar = editor.getParam('toolbar_sticky', false, 'boolean'); 10649 return (isStickyToolbar || editor.inline) && !useFixedContainer(editor) && !isDistractionFree(editor); 10650 }; 10651 var isDraggableModal = function (editor) { 10652 return editor.getParam('draggable_modal', false, 'boolean'); 10653 }; 10654 var getMenus = function (editor) { 10655 var menu = editor.getParam('menu'); 10656 if (menu) { 10657 return map$2(menu, function (menu) { 10658 return __assign(__assign({}, menu), { items: menu.items }); 10659 }); 10660 } else { 10661 return {}; 10662 } 10663 }; 10664 var getMenubar = function (editor) { 10665 return editor.getParam('menubar'); 10666 }; 10667 var getToolbar = function (editor) { 10668 return editor.getParam('toolbar', true); 10669 }; 10670 var getFilePickerCallback = function (editor) { 10671 return editor.getParam('file_picker_callback'); 10672 }; 10673 var getFilePickerTypes = function (editor) { 10674 return editor.getParam('file_picker_types'); 10675 }; 10676 var getFileBrowserCallbackTypes = function (editor) { 10677 return editor.getParam('file_browser_callback_types'); 10678 }; 10679 var noTypeaheadUrls = function (editor) { 10680 return editor.getParam('typeahead_urls') === false; 10681 }; 10682 var getAnchorTop = function (editor) { 10683 return editor.getParam('anchor_top', '#top'); 10684 }; 10685 var getAnchorBottom = function (editor) { 10686 return editor.getParam('anchor_bottom', '#bottom'); 10687 }; 10688 var getFilePickerValidatorHandler = function (editor) { 10689 var handler = editor.getParam('file_picker_validator_handler', undefined, 'function'); 10690 if (handler === undefined) { 10691 return editor.getParam('filepicker_validator_handler', undefined, 'function'); 10692 } else { 10693 return handler; 10694 } 10695 }; 10696 10697 var ReadOnlyChannel = 'silver.readonly'; 10698 var ReadOnlyDataSchema = objOf([strictBoolean('readonly')]); 10699 var broadcastReadonly = function (uiComponents, readonly) { 10700 var outerContainer = uiComponents.outerContainer; 10701 var target = outerContainer.element; 10702 if (readonly) { 10703 uiComponents.mothership.broadcastOn([dismissPopups()], { target: target }); 10704 uiComponents.uiMothership.broadcastOn([dismissPopups()], { target: target }); 10705 } 10706 uiComponents.mothership.broadcastOn([ReadOnlyChannel], { readonly: readonly }); 10707 uiComponents.uiMothership.broadcastOn([ReadOnlyChannel], { readonly: readonly }); 10708 }; 10709 var setupReadonlyModeSwitch = function (editor, uiComponents) { 10710 editor.on('init', function () { 10711 if (editor.mode.isReadOnly()) { 10712 broadcastReadonly(uiComponents, true); 10713 } 10714 }); 10715 editor.on('SwitchMode', function () { 10716 return broadcastReadonly(uiComponents, editor.mode.isReadOnly()); 10717 }); 10718 if (isReadOnly(editor)) { 10719 editor.setMode('readonly'); 10720 } 10721 }; 10722 var receivingConfig = function () { 10723 var _a; 10724 return Receiving.config({ 10725 channels: (_a = {}, _a[ReadOnlyChannel] = { 10726 schema: ReadOnlyDataSchema, 10727 onReceive: function (comp, data) { 10728 Disabling.set(comp, data.readonly); 10729 } 10730 }, _a) 10731 }); 10732 }; 10733 10734 var item = function (disabled) { 10735 return Disabling.config({ 10736 disabled: disabled, 10737 disableClass: 'tox-collection__item--state-disabled' 10738 }); 10739 }; 10740 var button = function (disabled) { 10741 return Disabling.config({ disabled: disabled }); 10742 }; 10743 var splitButton = function (disabled) { 10744 return Disabling.config({ 10745 disabled: disabled, 10746 disableClass: 'tox-tbtn--disabled' 10747 }); 10748 }; 10749 var toolbarButton = function (disabled) { 10750 return Disabling.config({ 10751 disabled: disabled, 10752 disableClass: 'tox-tbtn--disabled', 10753 useNative: false 10754 }); 10755 }; 10756 var DisablingConfigs = { 10757 item: item, 10758 button: button, 10759 splitButton: splitButton, 10760 toolbarButton: toolbarButton 10761 }; 10762 10763 var runWithApi = function (info, comp) { 10764 var api = info.getApi(comp); 10765 return function (f) { 10766 f(api); 10767 }; 10768 }; 10769 var onControlAttached = function (info, editorOffCell) { 10770 return runOnAttached(function (comp) { 10771 var run = runWithApi(info, comp); 10772 run(function (api) { 10773 var onDestroy = info.onSetup(api); 10774 if (isFunction(onDestroy)) { 10775 editorOffCell.set(onDestroy); 10776 } 10777 }); 10778 }); 10779 }; 10780 var onControlDetached = function (getApi, editorOffCell) { 10781 return runOnDetached(function (comp) { 10782 return runWithApi(getApi, comp)(editorOffCell.get()); 10783 }); 10784 }; 10785 10786 var _a; 10787 var onMenuItemExecute = function (info, itemResponse) { 10788 return runOnExecute(function (comp, simulatedEvent) { 10789 runWithApi(info, comp)(info.onAction); 10790 if (!info.triggersSubmenu && itemResponse === ItemResponse$1.CLOSE_ON_EXECUTE) { 10791 if (comp.getSystem().isConnected()) { 10792 emit(comp, sandboxClose()); 10793 } 10794 simulatedEvent.stop(); 10795 } 10796 }); 10797 }; 10798 var menuItemEventOrder = (_a = {}, _a[execute()] = [ 10799 'disabling', 10800 'alloy.base.behaviour', 10801 'toggling', 10802 'item-events' 10803 ], _a); 10804 10805 var componentRenderPipeline = function (xs) { 10806 return bind(xs, function (o) { 10807 return o.toArray(); 10808 }); 10809 }; 10810 var renderCommonItem = function (spec, structure, itemResponse, providersbackstage) { 10811 var editorOffCell = Cell(noop); 10812 return { 10813 type: 'item', 10814 dom: structure.dom, 10815 components: componentRenderPipeline(structure.optComponents), 10816 data: spec.data, 10817 eventOrder: menuItemEventOrder, 10818 hasSubmenu: spec.triggersSubmenu, 10819 itemBehaviours: derive$1([ 10820 config('item-events', [ 10821 onMenuItemExecute(spec, itemResponse), 10822 onControlAttached(spec, editorOffCell), 10823 onControlDetached(spec, editorOffCell) 10824 ]), 10825 DisablingConfigs.item(function () { 10826 return spec.disabled || providersbackstage.isDisabled(); 10827 }), 10828 receivingConfig(), 10829 Replacing.config({}) 10830 ].concat(spec.itemBehaviours)) 10831 }; 10832 }; 10833 var buildData = function (source) { 10834 return { 10835 value: source.value,
10836 meta: __assign({ text: source.text.getOr('') }, source.meta) 10837 }; 10838 }; 10839 10840 var global$8 = tinymce.util.Tools.resolve('tinymce.Env'); 10841 10842 var convertText = function (source) { 10843 var mac = { 10844 alt: '⌥', 10845 ctrl: '⌃', 10846 shift: '⇧', 10847 meta: '⌘', 10848 access: '⌃⌥' 10849 }; 10850 var other = { 10851 meta: 'Ctrl', 10852 access: 'Shift+Alt' 10853 }; 10854 var replace = global$8.mac ? mac : other; 10855 var shortcut = source.split('+'); 10856 var updated = map(shortcut, function (segment) { 10857 var search = segment.toLowerCase().trim(); 10858 return has(replace, search) ? replace[search] : segment; 10859 }); 10860 return global$8.mac ? updated.join('') : updated.join('+'); 10861 }; 10862 10863 var renderIcon = function (iconHtml) { 10864 return { 10865 dom: { 10866 tag: 'div', 10867 classes: [iconClass], 10868 innerHtml: iconHtml 10869 } 10870 }; 10871 }; 10872 var renderText = function (text$1) { 10873 return { 10874 dom: { 10875 tag: 'div', 10876 classes: [textClass] 10877 }, 10878 components: [text(global$6.translate(text$1))] 10879 }; 10880 }; 10881 var renderHtml = function (html, classes) { 10882 return { 10883 dom: { 10884 tag: 'div', 10885 classes: classes, 10886 innerHtml: html 10887 } 10888 }; 10889 }; 10890 var renderStyledText = function (style, text$1) { 10891 return { 10892 dom: { 10893 tag: 'div', 10894 classes: [textClass] 10895 }, 10896 components: [{ 10897 dom: { 10898 tag: style.tag, 10899 styles: style.styles 10900 }, 10901 components: [text(global$6.translate(text$1))] 10902 }] 10903 }; 10904 }; 10905 var renderShortcut = function (shortcut) { 10906 return { 10907 dom: { 10908 tag: 'div', 10909 classes: [accessoryClass], 10910 innerHtml: convertText(shortcut) 10911 } 10912 }; 10913 }; 10914 var renderCheckmark = function (icons) { 10915 return { 10916 dom: { 10917 tag: 'div', 10918 classes: [checkmarkClass], 10919 innerHtml: get$e('checkmark', icons) 10920 } 10921 }; 10922 }; 10923 var renderSubmenuCaret = function (icons) { 10924 return { 10925 dom: { 10926 tag: 'div', 10927 classes: [caretClass], 10928 innerHtml: get$e('chevron-right', icons) 10929 } 10930 }; 10931 }; 10932 var renderDownwardsCaret = function (icons) { 10933 return { 10934 dom: { 10935 tag: 'div', 10936 classes: [caretClass], 10937 innerHtml: get$e('chevron-down', icons) 10938 } 10939 }; 10940 }; 10941 var renderContainer = function (container, components) { 10942 var directionClass = container.direction === 'vertical' ? containerColumnClass : containerRowClass; 10943 var alignClass = container.align === 'left' ? containerAlignLeftClass : containerAlignRightClass; 10944 var getValignClass = function () { 10945 switch (container.valign) { 10946 case 'top': 10947 return containerValignTopClass; 10948 case 'middle': 10949 return containerValignMiddleClass; 10950 case 'bottom': 10951 return containerValignBottomClass; 10952 } 10953 }; 10954 return { 10955 dom: { 10956 tag: 'div', 10957 classes: [ 10958 containerClass, 10959 directionClass, 10960 alignClass, 10961 getValignClass() 10962 ] 10963 }, 10964 components: components 10965 }; 10966 }; 10967 var renderImage = function (src, classes, alt) { 10968 return { 10969 dom: { 10970 tag: 'img', 10971 classes: classes, 10972 attributes: { 10973 src: src, 10974 alt: alt.getOr('') 10975 } 10976 } 10977 }; 10978 }; 10979 10980 var renderColorStructure = function (itemText, itemValue, iconSvg, providerBackstage) { 10981 var colorPickerCommand = 'custom'; 10982 var removeColorCommand = 'remove'; 10983 var getDom = function () { 10984 var common = colorClass; 10985 var icon = iconSvg.getOr(''); 10986 var attributes = itemText.map(function (text) { 10987 return { title: providerBackstage.translate(text) }; 10988 }).getOr({}); 10989 var baseDom = { 10990 tag: 'div', 10991 attributes: attributes, 10992 classes: [common] 10993 }; 10994 if (itemValue === colorPickerCommand) { 10995 return __assign(__assign({}, baseDom), {
10996 tag: 'button', 10997 classes: __spreadArrays(baseDom.classes, ['tox-swatches__picker-btn']), 10998 innerHtml: icon 10999 }); 11000 } else if (itemValue === removeColorCommand) { 11001 return __assign(__assign({}, baseDom), { 11002 classes: __spreadArrays(baseDom.classes, ['tox-swatch--remove']), 11003 innerHtml: icon 11004 }); 11005 } else { 11006 return __assign(__assign({}, baseDom), { 11007 attributes: __assign(__assign({}, baseDom.attributes), { 'data-mce-color': itemValue }), 11008 styles: { 'background-color': itemValue } 11009 }); 11010 } 11011 }; 11012 return { 11013 dom: getDom(), 11014 optComponents: [] 11015 }; 11016 }; 11017 var renderItemDomStructure = function (rtlClass, ariaLabel) { 11018 var domTitle = ariaLabel.map(function (label) { 11019 return { attributes: { title: global$6.translate(label) } }; 11020 }).getOr({}); 11021 return __assign({ 11022 tag: 'div', 11023 classes: [ 11024 navClass, 11025 selectableClass 11026 ].concat(rtlClass ? [iconClassRtl] : []) 11027 }, domTitle); 11028 }; 11029 var renderNormalItemStructure = function (info, icon, renderIcons, textRender, rtlClass) { 11030 var leftIcon = renderIcons ? icon.or(Optional.some('')).map(renderIcon) : Optional.none(); 11031 var checkmark = info.checkMark; 11032 var content = info.htmlContent.fold(function () { 11033 return info.textContent.map(textRender); 11034 }, function (html) { 11035 return Optional.some(renderHtml(html, [textClass])); 11036 }); 11037 var menuItem = { 11038 dom: renderItemDomStructure(rtlClass, info.ariaLabel), 11039 optComponents: [ 11040 leftIcon, 11041 content, 11042 info.shortcutContent.map(renderShortcut), 11043 checkmark, 11044 info.caret 11045 ] 11046 }; 11047 return menuItem; 11048 }; 11049 var rtlIcon = [ 11050 'list-num-default', 11051 'list-num-lower-alpha', 11052 'list-num-lower-greek', 11053 'list-num-lower-roman', 11054 'list-num-upper-alpha', 11055 'list-num-upper-roman' 11056 ]; 11057 var rtlTransform = [ 11058 'list-bull-circle', 11059 'list-bull-default', 11060 'list-bull-square' 11061 ]; 11062 var renderItemStructure = function (info, providersBackstage, renderIcons, fallbackIcon) { 11063 if (fallbackIcon === void 0) { 11064 fallbackIcon = Optional.none(); 11065 } 11066 var getIconName = function (iconName) { 11067 return iconName.map(function (name) { 11068 return global$6.isRtl() && contains(rtlIcon, name) ? name + '-rtl' : name; 11069 }); 11070 }; 11071 var needRtlClass = global$6.isRtl() && info.iconContent.exists(function (name) { 11072 return contains(rtlTransform, name); 11073 }); 11074 var icon = getIconName(info.iconContent).map(function (iconName) { 11075 return getOr(iconName, providersBackstage.icons, fallbackIcon); 11076 }); 11077 var textRender = Optional.from(info.meta).fold(function () { 11078 return renderText; 11079 }, function (meta) { 11080 return has(meta, 'style') ? curry(renderStyledText, meta.style) : renderText; 11081 }); 11082 if (info.presets === 'color') { 11083 return renderColorStructure(info.ariaLabel, info.value, icon, providersBackstage); 11084 } else { 11085 return renderNormalItemStructure(info, icon, renderIcons, textRender, needRtlClass); 11086 } 11087 }; 11088 11089 var tooltipBehaviour = function (meta, sharedBackstage) { 11090 return get$1(meta, 'tooltipWorker').map(function (tooltipWorker) { 11091 return [Tooltipping.config({ 11092 lazySink: sharedBackstage.getSink, 11093 tooltipDom: { 11094 tag: 'div', 11095 classes: ['tox-tooltip-worker-container'] 11096 }, 11097 tooltipComponents: [], 11098 anchor: function (comp) { 11099 return { 11100 anchor: 'submenu', 11101 item: comp, 11102 overrides: { maxHeightFunction: expandable } 11103 }; 11104 }, 11105 mode: 'follow-highlight', 11106 onShow: function (component, _tooltip) { 11107 tooltipWorker(function (elm) { 11108 Tooltipping.setComponents(component, [external({ element: SugarElement.fromDom(elm) })]); 11109 }); 11110 } 11111 })]; 11112 }).getOr([]); 11113 }; 11114 var encodeText = function (text) { 11115 return global$5.DOM.encode(text); 11116 }; 11117 var replaceText = function (text, matchText) { 11118 var translated = global$6.translate(text); 11119 var encoded = encodeText(translated); 11120 if (matchText.length > 0) { 11121 var escapedMatchRegex = new RegExp(escape(matchText), 'gi'); 11122 return encoded.replace(escapedMatchRegex, function (match) { 11123 return '<span class="tox-autocompleter-highlight">' + match + '</span>'; 11124 }); 11125 } else { 11126 return encoded; 11127 } 11128 }; 11129 var renderAutocompleteItem = function (spec, matchText, useText, presets, onItemValueHandler, itemResponse, sharedBackstage, renderIcons) { 11130 if (renderIcons === void 0) { 11131 renderIcons = true; 11132 } 11133 var structure = renderItemStructure({ 11134 presets: presets, 11135 textContent: Optional.none(), 11136 htmlContent: useText ? spec.text.map(function (text) { 11137 return replaceText(text, matchText); 11138 }) : Optional.none(), 11139 ariaLabel: spec.text, 11140 iconContent: spec.icon, 11141 shortcutContent: Optional.none(), 11142 checkMark: Optional.none(), 11143 caret: Optional.none(), 11144 value: spec.value 11145 }, sharedBackstage.providers, renderIcons, spec.icon); 11146 return renderCommonItem({ 11147 data: buildData(spec), 11148 disabled: spec.disabled, 11149 getApi: constant({}), 11150 onAction: function (_api) { 11151 return onItemValueHandler(spec.value, spec.meta); 11152 }, 11153 onSetup: constant(noop), 11154 triggersSubmenu: false, 11155 itemBehaviours: tooltipBehaviour(spec.meta, sharedBackstage) 11156 }, structure, itemResponse, sharedBackstage.providers); 11157 }; 11158 11159 var render = function (items, extras) { 11160 return map(items, function (item) { 11161 switch (item.type) { 11162 case 'cardcontainer': 11163 return renderContainer(item, render(item.items, extras)); 11164 case 'cardimage': 11165 return renderImage(item.src, item.classes, item.alt); 11166 case 'cardtext': 11167 var shouldHighlight = item.name.exists(function (name) { 11168 return contains(extras.cardText.highlightOn, name); 11169 }); 11170 var matchText = shouldHighlight ? Optional.from(extras.cardText.matchText).getOr('') : ''; 11171 return renderHtml(replaceText(item.text, matchText), item.classes); 11172 } 11173 }); 11174 }; 11175 var renderCardMenuItem = function (spec, itemResponse, sharedBackstage, extras) { 11176 var getApi = function (component) { 11177 return { 11178 isDisabled: function () { 11179 return Disabling.isDisabled(component); 11180 }, 11181 setDisabled: function (state) { 11182 Disabling.set(component, state); 11183 each(descendants(component.element, '*'), function (elm) { 11184 component.getSystem().getByDom(elm).each(function (comp) { 11185 if (comp.hasConfigured(Disabling)) { 11186 Disabling.set(comp, state); 11187 } 11188 }); 11189 }); 11190 } 11191 }; 11192 }; 11193 var structure = { 11194 dom: renderItemDomStructure(false, spec.label), 11195 optComponents: [Optional.some({ 11196 dom: { 11197 tag: 'div', 11198 classes: [ 11199 containerClass, 11200 containerRowClass 11201 ] 11202 }, 11203 components: render(spec.items, extras) 11204 })] 11205 }; 11206 return renderCommonItem({ 11207 data: buildData(__assign({ text: Optional.none() }, spec)), 11208 disabled: spec.disabled, 11209 getApi: getApi, 11210 onAction: spec.onAction, 11211 onSetup: spec.onSetup, 11212 triggersSubmenu: false, 11213 itemBehaviours: Optional.from(extras.itemBehaviours).getOr([]) 11214 }, structure, itemResponse, sharedBackstage.providers); 11215 }; 11216 11217 var renderChoiceItem = function (spec, useText, presets, onItemValueHandler, isSelected, itemResponse, providersBackstage, renderIcons) { 11218 if (renderIcons === void 0) { 11219 renderIcons = true; 11220 } 11221 var getApi = function (component) { 11222 return {
11223 setActive: function (state) { 11224 Toggling.set(component, state); 11225 }, 11226 isActive: function () { 11227 return Toggling.isOn(component); 11228 }, 11229 isDisabled: function () { 11230 return Disabling.isDisabled(component); 11231 }, 11232 setDisabled: function (state) { 11233 return Disabling.set(component, state); 11234 } 11235 }; 11236 }; 11237 var structure = renderItemStructure({ 11238 presets: presets, 11239 textContent: useText ? spec.text : Optional.none(), 11240 htmlContent: Optional.none(), 11241 ariaLabel: spec.text, 11242 iconContent: spec.icon, 11243 shortcutContent: useText ? spec.shortcut : Optional.none(), 11244 checkMark: useText ? Optional.some(renderCheckmark(providersBackstage.icons)) : Optional.none(), 11245 caret: Optional.none(), 11246 value: spec.value 11247 }, providersBackstage, renderIcons); 11248 return deepMerge(renderCommonItem({ 11249 data: buildData(spec), 11250 disabled: spec.disabled, 11251 getApi: getApi, 11252 onAction: function (_api) { 11253 return onItemValueHandler(spec.value); 11254 }, 11255 onSetup: function (api) { 11256 api.setActive(isSelected); 11257 return noop; 11258 }, 11259 triggersSubmenu: false, 11260 itemBehaviours: [] 11261 }, structure, itemResponse, providersBackstage), { 11262 toggling: { 11263 toggleClass: tickedClass, 11264 toggleOnExecute: false, 11265 selected: spec.active 11266 } 11267 }); 11268 }; 11269 11270 var parts$2 = generate$4(owner$2(), parts()); 11271 11272 var hexColour = function (value) { 11273 return { value: value }; 11274 }; 11275 var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i; 11276 var longformRegex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i; 11277 var isHexString = function (hex) { 11278 return shorthandRegex.test(hex) || longformRegex.test(hex); 11279 }; 11280 var getLongForm = function (hex) { 11281 var hexString = hex.value.replace(shorthandRegex, function (m, r, g, b) { 11282 return r + r + g + g + b + b; 11283 }); 11284 return { value: hexString }; 11285 }; 11286 var extractValues = function (hex) { 11287 var longForm = getLongForm(hex); 11288 var splitForm = longformRegex.exec(longForm.value); 11289 return splitForm === null ? [ 11290 'FFFFFF', 11291 'FF', 11292 'FF', 11293 'FF' 11294 ] : splitForm; 11295 }; 11296 var toHex = function (component) { 11297 var hex = component.toString(16); 11298 return (hex.length === 1 ? '0' + hex : hex).toUpperCase(); 11299 }; 11300 var fromRgba = function (rgbaColour) { 11301 var value = toHex(rgbaColour.red) + toHex(rgbaColour.green) + toHex(rgbaColour.blue); 11302 return hexColour(value); 11303 }; 11304 11305 var min = Math.min; 11306 var max = Math.max; 11307 var round = Math.round; 11308 var rgbRegex = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)/; 11309 var rgbaRegex = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(\d?(?:\.\d+)?)\)/; 11310 var rgbaColour = function (red, green, blue, alpha) { 11311 return { 11312 red: red, 11313 green: green, 11314 blue: blue, 11315 alpha: alpha 11316 }; 11317 }; 11318 var isRgbaComponent = function (value) { 11319 var num = parseInt(value, 10); 11320 return num.toString() === value && num >= 0 && num <= 255; 11321 }; 11322 var fromHsv = function (hsv) { 11323 var r; 11324 var g; 11325 var b; 11326 var hue = (hsv.hue || 0) % 360; 11327 var saturation = hsv.saturation / 100; 11328 var brightness = hsv.value / 100; 11329 saturation = max(0, min(saturation, 1)); 11330 brightness = max(0, min(brightness, 1)); 11331 if (saturation === 0) { 11332 r = g = b = round(255 * brightness); 11333 return rgbaColour(r, g, b, 1); 11334 } 11335 var side = hue / 60; 11336 var chroma = brightness * saturation; 11337 var x = chroma * (1 - Math.abs(side % 2 - 1)); 11338 var match = brightness - chroma; 11339 switch (Math.floor(side)) { 11340 case 0: 11341 r = chroma; 11342 g = x; 11343 b = 0; 11344 break; 11345 case 1: 11346 r = x; 11347 g = chroma; 11348 b = 0; 11349 break; 11350 case 2: 11351 r = 0; 11352 g = chroma; 11353 b = x; 11354 break; 11355 case 3: 11356 r = 0; 11357 g = x; 11358 b = chroma; 11359 break; 11360 case 4: 11361 r = x; 11362 g = 0; 11363 b = chroma; 11364 break; 11365 case 5: 11366 r = chroma; 11367 g = 0; 11368 b = x; 11369 break; 11370 default: 11371 r = g = b = 0; 11372 } 11373 r = round(255 * (r + match)); 11374 g = round(255 * (g + match)); 11375 b = round(255 * (b + match)); 11376 return rgbaColour(r, g, b, 1); 11377 }; 11378 var fromHex = function (hexColour) { 11379 var result = extractValues(hexColour); 11380 var red = parseInt(result[1], 16); 11381 var green = parseInt(result[2], 16); 11382 var blue = parseInt(result[3], 16); 11383 return rgbaColour(red, green, blue, 1); 11384 }; 11385 var fromStringValues = function (red, green, blue, alpha) { 11386 var r = parseInt(red, 10); 11387 var g = parseInt(green, 10); 11388 var b = parseInt(blue, 10); 11389 var a = parseFloat(alpha); 11390 return rgbaColour(r, g, b, a); 11391 }; 11392 var fromString = function (rgbaString) { 11393 if (rgbaString === 'transparent') { 11394 return Optional.some(rgbaColour(0, 0, 0, 0)); 11395 } 11396 var rgbMatch = rgbRegex.exec(rgbaString); 11397 if (rgbMatch !== null) { 11398 return Optional.some(fromStringValues(rgbMatch[1], rgbMatch[2], rgbMatch[3], '1')); 11399 } 11400 var rgbaMatch = rgbaRegex.exec(rgbaString); 11401 if (rgbaMatch !== null) { 11402 return Optional.some(fromStringValues(rgbaMatch[1], rgbaMatch[2], rgbaMatch[3], rgbaMatch[4])); 11403 } 11404 return Optional.none(); 11405 }; 11406 var toString = function (rgba) { 11407 return 'rgba(' + rgba.red + ',' + rgba.green + ',' + rgba.blue + ',' + rgba.alpha + ')'; 11408 }; 11409 var red = rgbaColour(255, 0, 0, 1); 11410 11411 var fireSkinLoaded = function (editor) { 11412 return editor.fire('SkinLoaded'); 11413 }; 11414 var fireSkinLoadError = function (editor, error) { 11415 return editor.fire('SkinLoadError', error); 11416 }; 11417 var fireResizeEditor = function (editor) { 11418 return editor.fire('ResizeEditor'); 11419 }; 11420 var fireResizeContent = function (editor, e) { 11421 return editor.fire('ResizeContent', e); 11422 }; 11423 var fireScrollContent = function (editor, e) { 11424 return editor.fire('ScrollContent', e); 11425 }; 11426 var fireTextColorChange = function (editor, data) { 11427 return editor.fire('TextColorChange', data); 11428 }; 11429 11430 var global$9 = tinymce.util.Tools.resolve('tinymce.util.LocalStorage'); 11431 11432 var storageName = 'tinymce-custom-colors'; 11433 function ColorCache (max) { 11434 if (max === void 0) { 11435 max = 10; 11436 } 11437 var storageString = global$9.getItem(storageName); 11438 var localstorage = isString(storageString) ? JSON.parse(storageString) : []; 11439 var prune = function (list) { 11440 var diff = max - list.length; 11441 return diff < 0 ? list.slice(0, max) : list; 11442 }; 11443 var cache = prune(localstorage); 11444 var add = function (key) { 11445 indexOf(cache, key).each(remove); 11446 cache.unshift(key); 11447 if (cache.length > max) { 11448 cache.pop(); 11449 } 11450 global$9.setItem(storageName, JSON.stringify(cache)); 11451 }; 11452 var remove = function (idx) { 11453 cache.splice(idx, 1); 11454 }; 11455 var state = function () { 11456 return cache.slice(0); 11457 }; 11458 return { 11459 add: add, 11460 state: state 11461 }; 11462 } 11463 11464 var choiceItem = 'choiceitem'; 11465 var defaultColors = [ 11466 { 11467 type: choiceItem, 11468 text: 'Light Green', 11469 value: '#BFEDD2' 11470 }, 11471 { 11472 type: choiceItem, 11473 text: 'Light Yellow', 11474 value: '#FBEEB8' 11475 }, 11476 { 11477 type: choiceItem, 11478 text: 'Light Red', 11479 value: '#F8CAC6' 11480 }, 11481 { 11482 type: choiceItem, 11483 text: 'Light Purple', 11484 value: '#ECCAFA' 11485 }, 11486 { 11487 type: choiceItem, 11488 text: 'Light Blue', 11489 value: '#C2E0F4' 11490 }, 11491 { 11492 type: choiceItem, 11493 text: 'Green', 11494 value: '#2DC26B' 11495 }, 11496 { 11497 type: choiceItem, 11498 text: 'Yellow', 11499 value: '#F1C40F' 11500 }, 11501 { 11502 type: choiceItem, 11503 text: 'Red', 11504 value: '#E03E2D' 11505 }, 11506 { 11507 type: choiceItem, 11508 text: 'Purple', 11509 value: '#B96AD9' 11510 }, 11511 { 11512 type: choiceItem, 11513 text: 'Blue', 11514 value: '#3598DB' 11515 }, 11516 { 11517 type: choiceItem, 11518 text: 'Dark Turquoise', 11519 value: '#169179' 11520 }, 11521 { 11522 type: choiceItem, 11523 text: 'Orange', 11524 value: '#E67E23' 11525 }, 11526 { 11527 type: choiceItem, 11528 text: 'Dark Red', 11529 value: '#BA372A' 11530 }, 11531 { 11532 type: choiceItem, 11533 text: 'Dark Purple', 11534 value: '#843FA1' 11535 }, 11536 { 11537 type: choiceItem, 11538 text: 'Dark Blue', 11539 value: '#236FA1' 11540 }, 11541 { 11542 type: choiceItem, 11543 text: 'Light Gray', 11544 value: '#ECF0F1' 11545 }, 11546 { 11547 type: choiceItem, 11548 text: 'Medium Gray', 11549 value: '#CED4D9' 11550 }, 11551 { 11552 type: choiceItem, 11553 text: 'Gray', 11554 value: '#95A5A6' 11555 }, 11556 { 11557 type: choiceItem, 11558 text: 'Dark Gray', 11559 value: '#7E8C8D' 11560 }, 11561 { 11562 type: choiceItem, 11563 text: 'Navy Blue', 11564 value: '#34495E' 11565 }, 11566 { 11567 type: choiceItem, 11568 text: 'Black', 11569 value: '#000000' 11570 }, 11571 { 11572 type: choiceItem, 11573 text: 'White', 11574 value: '#ffffff' 11575 } 11576 ]; 11577 var colorCache = ColorCache(10); 11578 var mapColors = function (colorMap) { 11579 var colors = []; 11580 var canvas = document.createElement('canvas'); 11581 canvas.height = 1; 11582 canvas.width = 1; 11583 var ctx = canvas.getContext('2d'); 11584 var byteAsHex = function (colorByte, alphaByte) { 11585 var bg = 255; 11586 var alpha = alphaByte / 255; 11587 var colorByteWithWhiteBg = Math.round(colorByte * alpha + bg * (1 - alpha)); 11588 return ('0' + colorByteWithWhiteBg.toString(16)).slice(-2).toUpperCase(); 11589 }; 11590 var asHexColor = function (color) { 11591 if (/^[0-9A-Fa-f]{6}$/.test(color)) { 11592 return '#' + color.toUpperCase(); 11593 } 11594 ctx.clearRect(0, 0, canvas.width, canvas.height); 11595 ctx.fillStyle = '#FFFFFF'; 11596 ctx.fillStyle = color; 11597 ctx.fillRect(0, 0, 1, 1); 11598 var rgba = ctx.getImageData(0, 0, 1, 1).data; 11599 var r = rgba[0], g = rgba[1], b = rgba[2], a = rgba[3]; 11600 return '#' + byteAsHex(r, a) + byteAsHex(g, a) + byteAsHex(b, a); 11601 }; 11602 for (var i = 0; i < colorMap.length; i += 2) { 11603 colors.push({ 11604 text: colorMap[i + 1], 11605 value: asHexColor(colorMap[i]), 11606 type: 'choiceitem' 11607 }); 11608 } 11609 return colors; 11610 };
11611 var getColorCols = function (editor, defaultCols) { 11612 return editor.getParam('color_cols', defaultCols, 'number'); 11613 }; 11614 var hasCustomColors = function (editor) { 11615 return editor.getParam('custom_colors') !== false; 11616 }; 11617 var getColorMap = function (editor) { 11618 return editor.getParam('color_map'); 11619 }; 11620 var getColors = function (editor) { 11621 var unmapped = getColorMap(editor); 11622 return unmapped !== undefined ? mapColors(unmapped) : defaultColors; 11623 }; 11624 var getCurrentColors = function () { 11625 return map(colorCache.state(), function (color) { 11626 return { 11627 type: choiceItem, 11628 text: color, 11629 value: color 11630 }; 11631 }); 11632 }; 11633 var addColor = function (color) { 11634 colorCache.add(color); 11635 }; 11636 11637 var getCurrentColor = function (editor, format) { 11638 var color; 11639 editor.dom.getParents(editor.selection.getStart(), function (elm) { 11640 var value; 11641 if (value = elm.style[format === 'forecolor' ? 'color' : 'background-color']) { 11642 color = color ? color : value; 11643 } 11644 }); 11645 return color; 11646 }; 11647 var applyFormat = function (editor, format, value) { 11648 editor.undoManager.transact(function () { 11649 editor.focus(); 11650 editor.formatter.apply(format, { value: value }); 11651 editor.nodeChanged(); 11652 }); 11653 }; 11654 var removeFormat = function (editor, format) { 11655 editor.undoManager.transact(function () { 11656 editor.focus(); 11657 editor.formatter.remove(format, { value: null }, null, true); 11658 editor.nodeChanged(); 11659 }); 11660 }; 11661 var registerCommands = function (editor) { 11662 editor.addCommand('mceApplyTextcolor', function (format, value) { 11663 applyFormat(editor, format, value); 11664 }); 11665 editor.addCommand('mceRemoveTextcolor', function (format) { 11666 removeFormat(editor, format); 11667 }); 11668 }; 11669 var calcCols = function (colors) { 11670 return Math.max(5, Math.ceil(Math.sqrt(colors))); 11671 }; 11672 var getColorCols$1 = function (editor) { 11673 var colors = getColors(editor); 11674 var defaultCols = calcCols(colors.length); 11675 return getColorCols(editor, defaultCols); 11676 }; 11677 var getAdditionalColors = function (hasCustom) { 11678 var type = 'choiceitem'; 11679 var remove = { 11680 type: type, 11681 text: 'Remove color', 11682 icon: 'color-swatch-remove-color', 11683 value: 'remove' 11684 }; 11685 var custom = { 11686 type: type, 11687 text: 'Custom color', 11688 icon: 'color-picker', 11689 value: 'custom' 11690 };
11691 return hasCustom ? [ 11692 remove, 11693 custom 11694 ] : [remove]; 11695 }; 11696 var applyColor = function (editor, format, value, onChoice) { 11697 if (value === 'custom') { 11698 var dialog = colorPickerDialog(editor); 11699 dialog(function (colorOpt) { 11700 colorOpt.each(function (color) { 11701 addColor(color); 11702 editor.execCommand('mceApplyTextcolor', format, color); 11703 onChoice(color); 11704 }); 11705 }, '#000000'); 11706 } else if (value === 'remove') { 11707 onChoice(''); 11708 editor.execCommand('mceRemoveTextcolor', format); 11709 } else { 11710 onChoice(value); 11711 editor.execCommand('mceApplyTextcolor', format, value); 11712 } 11713 }; 11714 var getColors$1 = function (colors, hasCustom) { 11715 return colors.concat(getCurrentColors().concat(getAdditionalColors(hasCustom))); 11716 }; 11717 var getFetch = function (colors, hasCustom) { 11718 return function (callback) { 11719 callback(getColors$1(colors, hasCustom)); 11720 }; 11721 }; 11722 var setIconColor = function (splitButtonApi, name, newColor) { 11723 var id = name === 'forecolor' ? 'tox-icon-text-color__color' : 'tox-icon-highlight-bg-color__color'; 11724 splitButtonApi.setIconFill(id, newColor); 11725 }; 11726 var registerTextColorButton = function (editor, name, format, tooltip, lastColor) { 11727 editor.ui.registry.addSplitButton(name, { 11728 tooltip: tooltip, 11729 presets: 'color', 11730 icon: name === 'forecolor' ? 'text-color' : 'highlight-bg-color', 11731 select: function (value) { 11732 var optCurrentRgb = Optional.from(getCurrentColor(editor, format)); 11733 return optCurrentRgb.bind(function (currentRgb) { 11734 return fromString(currentRgb).map(function (rgba) { 11735 var currentHex = fromRgba(rgba).value; 11736 return contains$1(value.toLowerCase(), currentHex); 11737 }); 11738 }).getOr(false); 11739 }, 11740 columns: getColorCols$1(editor), 11741 fetch: getFetch(getColors(editor), hasCustomColors(editor)), 11742 onAction: function (_splitButtonApi) { 11743 if (lastColor.get() !== null) { 11744 applyColor(editor, format, lastColor.get(), noop); 11745 } 11746 }, 11747 onItemAction: function (_splitButtonApi, value) { 11748 applyColor(editor, format, value, function (newColor) { 11749 lastColor.set(newColor); 11750 fireTextColorChange(editor, { 11751 name: name, 11752 color: newColor 11753 }); 11754 }); 11755 }, 11756 onSetup: function (splitButtonApi) { 11757 if (lastColor.get() !== null) { 11758 setIconColor(splitButtonApi, name, lastColor.get()); 11759 } 11760 var handler = function (e) { 11761 if (e.name === name) { 11762 setIconColor(splitButtonApi, e.name, e.color); 11763 } 11764 }; 11765 editor.on('TextColorChange', handler); 11766 return function () { 11767 editor.off('TextColorChange', handler); 11768 }; 11769 } 11770 }); 11771 }; 11772 var registerTextColorMenuItem = function (editor, name, format, text) { 11773 editor.ui.registry.addNestedMenuItem(name, { 11774 text: text, 11775 icon: name === 'forecolor' ? 'text-color' : 'highlight-bg-color', 11776 getSubmenuItems: function () { 11777 return [{ 11778 type: 'fancymenuitem', 11779 fancytype: 'colorswatch', 11780 onAction: function (data) { 11781 applyColor(editor, format, data.value, noop); 11782 } 11783 }]; 11784 } 11785 }); 11786 }; 11787 var colorPickerDialog = function (editor) { 11788 return function (callback, value) { 11789 var isValid = false; 11790 var onSubmit = function (api) { 11791 var data = api.getData(); 11792 var hex = data.colorpicker; 11793 if (isValid) { 11794 callback(Optional.from(hex)); 11795 api.close(); 11796 } else { 11797 editor.windowManager.alert(editor.translate([ 11798 'Invalid hex color code: {0}', 11799 hex 11800 ])); 11801 } 11802 }; 11803 var onAction = function (_api, details) { 11804 if (details.name === 'hex-valid') { 11805 isValid = details.value; 11806 } 11807 }; 11808 var initialData = { colorpicker: value }; 11809 editor.windowManager.open({ 11810 title: 'Color Picker', 11811 size: 'normal', 11812 body: { 11813 type: 'panel', 11814 items: [{ 11815 type: 'colorpicker', 11816 name: 'colorpicker', 11817 label: 'Color' 11818 }] 11819 }, 11820 buttons: [ 11821 { 11822 type: 'cancel', 11823 name: 'cancel', 11824 text: 'Cancel' 11825 }, 11826 { 11827 type: 'submit', 11828 name: 'save', 11829 text: 'Save', 11830 primary: true 11831 } 11832 ], 11833 initialData: initialData, 11834 onAction: onAction, 11835 onSubmit: onSubmit, 11836 onClose: noop, 11837 onCancel: function () { 11838 callback(Optional.none()); 11839 } 11840 }); 11841 }; 11842 }; 11843 var register$1 = function (editor) { 11844 registerCommands(editor); 11845 var lastForeColor = Cell(null); 11846 var lastBackColor = Cell(null); 11847 registerTextColorButton(editor, 'forecolor', 'forecolor', 'Text color', lastForeColor); 11848 registerTextColorButton(editor, 'backcolor', 'hilitecolor', 'Backgroun
11848d color', lastBackColor); 11849 registerTextColorMenuItem(editor, 'forecolor', 'forecolor', 'Text color'); 11850 registerTextColorMenuItem(editor, 'backcolor', 'hilitecolor', 'Background color'); 11851 }; 11852 11853 var createPartialChoiceMenu = function (value, items, onItemValueHandler, columns, presets, itemResponse, select, providersBackstage) { 11854 var hasIcons = menuHasIcons(items); 11855 var presetItemTypes = presets !== 'color' ? 'normal' : 'color'; 11856 var alloyItems = createChoiceItems(items, onItemValueHandler, columns, presetItemTypes, itemResponse, select, providersBackstage); 11857 return createPartialMenuWithAlloyItems(value, hasIcons, alloyItems, columns, presets); 11858 }; 11859 var createChoiceItems = function (items, onItemValueHandler, columns, itemPresets, itemResponse, select, providersBackstage) { 11860 return cat(map(items, function (item) { 11861 if (item.type === 'choiceitem') { 11862 return createChoiceMenuItem(item).fold(handleError, function (d) { 11863 return Optional.some(renderChoiceItem(d, columns === 1, itemPresets, onItemValueHandler, select(item.value), itemResponse, providersBackstage, menuHasIcons(items))); 11864 }); 11865 } else { 11866 return Optional.none(); 11867 } 11868 })); 11869 }; 11870 11871 var deriveMenuMovement = function (columns, presets) { 11872 var menuMarkers = markers$1(presets); 11873 if (columns === 1) { 11874 return { 11875 mode: 'menu', 11876 moveOnTab: true 11877 }; 11878 } else if (columns === 'auto') { 11879 return { 11880 mode: 'grid', 11881 selector: '.' + menuMarkers.item, 11882 initSize: { 11883 numColumns: 1, 11884 numRows: 1 11885 } 11886 }; 11887 } else { 11888 var rowClass = presets === 'color' ? 'tox-swatches__row' : 'tox-collection__group'; 11889 return { 11890 mode: 'matrix', 11891 rowSelector: '.' + rowClass 11892 }; 11893 } 11894 }; 11895 var deriveCollectionMovement = function (columns, presets) { 11896 if (columns === 1) { 11897 return { 11898 mode: 'menu', 11899 moveOnTab: false, 11900 selector: '.tox-collection__item' 11901 }; 11902 } else if (columns === 'auto') { 11903 return { 11904 mode: 'flatgrid', 11905 selector: '.' + 'tox-collection__item', 11906 initSize: { 11907 numColumns: 1, 11908 numRows: 1 11909 } 11910 }; 11911 } else { 11912 return { 11913 mode: 'matrix', 11914 selectors: { 11915 row: presets === 'color' ? '.tox-swatches__row' : '.tox-collection__group', 11916 cell: presets === 'color' ? '.' + colorClass : '.' + selectableClass 11917 } 11918 }; 11919 } 11920 }; 11921 11922 var renderColorSwatchItem = function (spec, backstage) { 11923 var items = getColors$1(backstage.colorinput.getColors(), backstage.colorinput.hasCustomColors()); 11924 var columns = backstage.colorinput.getColorCols(); 11925 var presets = 'color'; 11926 var menuSpec = createPartialChoiceMenu(generate$1('menu-value'), items, function (value) { 11927 spec.onAction({ value: value }); 11928 }, columns, presets, ItemResponse$1.CLOSE_ON_EXECUTE, never, backstage.shared.providers); 11929 var widgetSpec = __assign(__assign({}, menuSpec), { 11930 markers: markers$1(presets), 11931 movement: deriveMenuMovement(columns, presets) 11932 }); 11933 return { 11934 type: 'widget', 11935 data: { value: generate$1('widget-id') }, 11936 dom: { 11937 tag: 'div', 11938 classes: ['tox-fancymenuitem'] 11939 }, 11940 autofocus: true, 11941 components: [parts$2.widget(Menu.sketch(widgetSpec))] 11942 }; 11943 }; 11944 11945 var cellOverEvent = generate$1('cell-over'); 11946 var cellExecuteEvent = generate$1('cell-execute'); 11947 var makeCell = function (row, col, labelId) { 11948 var _a; 11949 var emitCellOver = function (c) { 11950 return emitWith(c, cellOverEvent, { 11951 row: row, 11952 col: col 11953 }); 11954 }; 11955 var emitExecute = function (c) { 11956 return emitWith(c, cellExecuteEvent, { 11957 row: row, 11958 col: col 11959 }); 11960 }; 11961 var onClick = function (c, se) { 11962 se.stop(); 11963 emitExecute(c); 11964 }; 11965 return build$1({ 11966 dom: { 11967 tag: 'div', 11968 attributes: (_a = { role: 'button' }, _a['aria-labelledby'] = labelId, _a) 11969 }, 11970 behaviours: derive$1([ 11971 config('insert-table-picker-cell', [ 11972 run(mouseover(), Focusing.focus), 11973 run(execute(), emitExecute), 11974 run(click(), onClick), 11975 run(tap(), onClick) 11976 ]), 11977 Toggling.config({ 11978 toggleClass: 'tox-insert-table-picker__selected', 11979 toggleOnExecute: false 11980 }), 11981 Focusing.config({ onFocus: emitCellOver }) 11982 ]) 11983 }); 11984 }; 11985 var makeCells = function (labelId, numRows, numCols) { 11986 var cells = []; 11987 for (var i = 0; i < numRows; i++) { 11988 var row = []; 11989 for (var j = 0; j < numCols; j++) { 11990 row.push(makeCell(i, j, labelId)); 11991 } 11992 cells.push(row); 11993 } 11994 return cells; 11995 }; 11996 var selectCells = function (cells, selectedRow, selectedColumn, numRows, numColumns) { 11997 for (var i = 0; i < numRows; i++) { 11998 for (var j = 0; j < numColumns; j++) { 11999 Toggling.set(cells[i][j], i <= selectedRow && j <= selectedColumn); 12000 } 12001 } 12002 }; 12003 var makeComponents = function (cells) { 12004 return bind(cells, function (cellRow) { 12005 return map(cellRow, premade$1); 12006 }); 12007 }; 12008 var makeLabelText = function (row, col) { 12009 return text(col + 1 + 'x' + (row + 1)); 12010 }; 12011 var renderInsertTableMenuItem = function (spec) { 12012 var numRows = 10; 12013 var numColumns = 10; 12014 var sizeLabelId = generate$1('size-label'); 12015 var cells = makeCells(sizeLabelId, numRows, numColumns); 12016 var memLabel = record({ 12017 dom: { 12018 tag: 'span', 12019 classes: ['tox-insert-table-picker__label'], 12020 attributes: { id: sizeLabelId } 12021 }, 12022 components: [text('0x0')], 12023 behaviours: derive$1([Replacing.config({})]) 12024 }); 12025 return { 12026 type: 'widget', 12027 data: { value: generate$1('widget-id') }, 12028 dom: { 12029 tag: 'div', 12030 classes: ['tox-fancymenuitem'] 12031 }, 12032 autofocus: true, 12033 components: [parts$2.widget({ 12034 dom: { 12035 tag: 'div', 12036 classes: ['tox-insert-table-picker'] 12037 }, 12038 components: makeComponents(cells).concat(memLabel.asSpec()), 12039 behaviours: derive$1([ 12040 config('insert-table-picker', [ 12041 runWithTarget(cellOverEvent, function (c, t, e) { 12042 var row = e.event.row; 12043 var col = e.event.col;
12044 selectCells(cells, row, col, numRows, numColumns); 12045 Replacing.set(memLabel.get(c), [makeLabelText(row, col)]); 12046 }), 12047 runWithTarget(cellExecuteEvent, function (c, _, e) { 12048 spec.onAction({ 12049 numRows: e.event.row + 1, 12050 numColumns: e.event.col + 1 12051 }); 12052 emit(c, sandboxClose()); 12053 }) 12054 ]), 12055 Keying.config({ 12056 initSize: { 12057 numRows: numRows, 12058 numColumns: numColumns 12059 }, 12060 mode: 'flatgrid', 12061 selector: '[role="button"]' 12062 }) 12063 ]) 12064 })] 12065 }; 12066 }; 12067 12068 var fancyMenuItems = { 12069 inserttable: renderInsertTableMenuItem, 12070 colorswatch: renderColorSwatchItem 12071 }; 12072 var valueOpt = function (obj, key) { 12073 return Object.prototype.hasOwnProperty.call(obj, key) ? Optional.some(obj[key]) : Optional.none(); 12074 }; 12075 var renderFancyMenuItem = function (spec, backstage) { 12076 return valueOpt(fancyMenuItems, spec.fancytype).map(function (render) { 12077 return render(spec, backstage); 12078 }); 12079 }; 12080 12081 var renderNestedItem = function (spec, itemResponse, providersBackstage, renderIcons, downwardsCaret) { 12082 if (renderIcons === void 0) { 12083 renderIcons = true; 12084 } 12085 if (downwardsCaret === void 0) { 12086 downwardsCaret = false; 12087 } 12088 var caret = downwardsCaret ? renderDownwardsCaret(providersBackstage.icons) : renderSubmenuCaret(providersBackstage.icons); 12089 var getApi = function (component) { 12090 return { 12091 isDisabled: function () { 12092 return Disabling.isDisabled(component); 12093 }, 12094 setDisabled: function (state) { 12095 return Disabling.set(component, state); 12096 } 12097 }; 12098 }; 12099 var structure = renderItemStructure({ 12100 presets: 'normal', 12101 iconContent: spec.icon, 12102 textContent: spec.text, 12103 htmlContent: Optional.none(), 12104 ariaLabel: spec.text, 12105 caret: Optional.some(caret), 12106 checkMark: Optional.none(), 12107 shortcutContent: spec.shortcut 12108 }, providersBackstage, renderIcons); 12109 return renderCommonItem({ 12110 data: buildData(spec), 12111 getApi: getApi, 12112 disabled: spec.disabled, 12113 onAction: noop, 12114 onSetup: spec.onSetup, 12115 triggersSubmenu: true, 12116 itemBehaviours: [] 12117 }, structure, itemResponse, providersBackstage); 12118 }; 12119 12120 var renderNormalItem = function (spec, itemResponse, providersBackstage, renderIcons) { 12121 if (renderIcons === void 0) { 12122 renderIcons = true; 12123 } 12124 var getApi = function (component) { 12125 return { 12126 isDisabled: function () { 12127 return Disabling.isDisabled(component); 12128 }, 12129 setDisabled: function (state) { 12130 return Disabling.set(component, state); 12131 } 12132 }; 12133 }; 12134 var structure = renderItemStructure({ 12135 presets: 'normal', 12136 iconContent: spec.icon, 12137 textContent: spec.text, 12138 htmlContent: Optional.none(), 12139 ariaLabel: spec.text, 12140 caret: Optional.none(), 12141 checkMark: Optional.none(), 12142 shortcutContent: spec.shortcut 12143 }, providersBackstage, renderIcons); 12144 return renderCommonItem({ 12145 data: buildData(spec), 12146 getApi: getApi, 12147 disabled: spec.disabled, 12148 onAction: spec.onAction, 12149 onSetup: spec.onSetup, 12150 triggersSubmenu: false, 12151 itemBehaviours: [] 12152 }, structure, itemResponse, providersBackstage); 12153 }; 12154 12155 var renderSeparatorItem = function (spec) { 12156 var innerHtml = spec.text.fold(function () { 12157 return {}; 12158 }, function (text) { 12159 return { innerHtml: text }; 12160 }); 12161 return { 12162 type: 'separator', 12163 dom: __assign({ 12164 tag: 'div', 12165 classes: [ 12166 selectableClass, 12167 groupHeadingClass 12168 ] 12169 }, innerHtml), 12170 components: [] 12171 }; 12172 }; 12173 12174 var renderToggleMenuItem = function (spec, itemResponse, providersBackstage, renderIcons) { 12175 if (renderIcons === void 0) { 12176 renderIcons = true; 12177 } 12178 var getApi = function (component) { 12179 return {
12180 setActive: function (state) { 12181 Toggling.set(component, state); 12182 }, 12183 isActive: function () { 12184 return Toggling.isOn(component); 12185 }, 12186 isDisabled: function () { 12187 return Disabling.isDisabled(component); 12188 }, 12189 setDisabled: function (state) { 12190 return Disabling.set(component, state); 12191 } 12192 }; 12193 }; 12194 var structure = renderItemStructure({ 12195 iconContent: spec.icon, 12196 textContent: spec.text, 12197 htmlContent: Optional.none(), 12198 ariaLabel: spec.text, 12199 checkMark: Optional.some(renderCheckmark(providersBackstage.icons)), 12200 caret: Optional.none(), 12201 shortcutContent: spec.shortcut, 12202 presets: 'normal', 12203 meta: spec.meta 12204 }, providersBackstage, renderIcons); 12205 return deepMerge(renderCommonItem({ 12206 data: buildData(spec), 12207 disabled: spec.disabled, 12208 getApi: getApi, 12209 onAction: spec.onAction, 12210 onSetup: spec.onSetup, 12211 triggersSubmenu: false, 12212 itemBehaviours: [] 12213 }, structure, itemResponse, providersBackstage), { 12214 toggling: { 12215 toggleClass: tickedClass, 12216 toggleOnExecute: false, 12217 selected: spec.active 12218 } 12219 }); 12220 }; 12221 12222 var autocomplete = renderAutocompleteItem; 12223 var separator = renderSeparatorItem; 12224 var normal = renderNormalItem; 12225 var nested = renderNestedItem; 12226 var toggle$1 = renderToggleMenuItem; 12227 var fancy = renderFancyMenuItem; 12228 var card = renderCardMenuItem; 12229 12230 var FocusMode; 12231 (function (FocusMode) { 12232 FocusMode[FocusMode['ContentFocus'] = 0] = 'ContentFocus'; 12233 FocusMode[FocusMode['UiFocus'] = 1] = 'UiFocus'; 12234 }(FocusMode || (FocusMode = {}))); 12235 var createMenuItemFromBridge = function (item, itemResponse, backstage, menuHasIcons, isHorizontalMenu) { 12236 var providersBackstage = backstage.shared.providers; 12237 var parseForHorizontalMenu = function (menuitem) { 12238 return !isHorizontalMenu ? menuitem : __assign(__assign({}, menuitem), { 12239 shortcut: Optional.none(), 12240 icon: menuitem.text.isSome() ? Optional.none() : menuitem.icon 12241 }); 12242 }; 12243 switch (item.type) { 12244 case 'menuitem': 12245 return createMenuItem(item).fold(handleError, function (d) { 12246 return Optional.some(normal(parseForHorizontalMenu(d), itemResponse, providersBackstage, menuHasIcons)); 12247 }); 12248 case 'nestedmenuitem': 12249 return createNestedMenuItem(item).fold(handleError, function (d) { 12250 return Optional.some(nested(parseForHorizontalMenu(d), itemResponse, providersBackstage, menuHasIcons, isHorizontalMenu)); 12251 }); 12252 case 'togglemenuitem': 12253 return createToggleMenuItem(item).fold(handleError, function (d) { 12254 return Optional.some(toggle$1(parseForHorizontalMenu(d), itemResponse, providersBackstage, menuHasIcons)); 12255 }); 12256 case 'separator': 12257 return createSeparatorMenuItem(item).fold(handleError, function (d) { 12258 return Optional.some(separator(d)); 12259 }); 12260 case 'fancymenuitem': 12261 return createFancyMenuItem(item).fold(handleError, function (d) { 12262 return fancy(parseForHorizontalMenu(d), backstage); 12263 }); 12264 default: { 12265 console.error('Unknown item in general menu', item); 12266 return Optional.none(); 12267 } 12268 } 12269 }; 12270 var createAutocompleteItems = function (items, matchText, onItemValueHandler, columns, itemResponse, sharedBackstage, highlightOn) { 12271 var renderText = columns === 1; 12272 var renderIcons = !renderText || menuHasIcons(items); 12273 return cat(map(items, function (item) { 12274 switch (item.type) { 12275 case 'separator': 12276 return createSeparatorItem(item).fold(handleError, function (d) { 12277 return Optional.some(separator(d)); 12278 }); 12279 case 'cardmenuitem': 12280 return createCardMenuItem(item).fold(handleError, function (d) { 12281 return Optional.some(card(__assign(__assign({}, d), { 12282 onAction: function (api) { 12283 d.onAction(api); 12284 onItemValueHandler(d.value, d.meta); 12285 } 12286 }), itemResponse, sharedBackstage, { 12287 itemBehaviours: tooltipBehaviour(d.meta, sharedBackstage), 12288 cardText: { 12289 matchText: matchText, 12290 highlightOn: highlightOn 12291 } 12292 })); 12293 }); 12294 case 'autocompleteitem': 12295 default: 12296 return createAutocompleterItem(item).fold(handleError, function (d) { 12297 return Optional.some(autocomplete(d, matchText, renderText, 'normal', onItemValueHandler, itemResponse, sharedBackstage, renderIcons)); 12298 }); 12299 } 12300 })); 12301 };
12302 var createPartialMenu = function (value, items, itemResponse, backstage, isHorizontalMenu) { 12303 var hasIcons = menuHasIcons(items); 12304 var alloyItems = cat(map(items, function (item) { 12305 var itemHasIcon = function (i) { 12306 return isHorizontalMenu ? !i.hasOwnProperty('text') : hasIcons; 12307 }; 12308 var createItem = function (i) { 12309 return createMenuItemFromBridge(i, itemResponse, backstage, itemHasIcon(i), isHorizontalMenu); 12310 }; 12311 if (item.type === 'nestedmenuitem' && item.getSubmenuItems().length <= 0) { 12312 return createItem(__assign(__assign({}, item), { disabled: true })); 12313 } else { 12314 return createItem(item); 12315 } 12316 })); 12317 var createPartial = isHorizontalMenu ? createHorizontalPartialMenuWithAlloyItems : createPartialMenuWithAlloyItems; 12318 return createPartial(value, hasIcons, alloyItems, 1, 'normal'); 12319 }; 12320 var createTieredDataFrom = function (partialMenu) { 12321 return tieredMenu.singleData(partialMenu.value, partialMenu); 12322 }; 12323 var createMenuFrom = function (partialMenu, columns, focusMode, presets) { 12324 var focusManager = focusMode === FocusMode.ContentFocus ? highlights() : dom(); 12325 var movement = deriveMenuMovement(columns, presets); 12326 var menuMarkers = markers$1(presets); 12327 return { 12328 dom: partialMenu.dom, 12329 components: partialMenu.components, 12330 items: partialMenu.items, 12331 value: partialMenu.value, 12332 markers: { 12333 selectedItem: menuMarkers.selectedItem, 12334 item: menuMarkers.item 12335 }, 12336 movement: movement, 12337 fakeFocus: focusMode === FocusMode.ContentFocus, 12338 focusManager: focusManager, 12339 menuBehaviours: SimpleBehaviours.unnamedEvents(columns !== 'auto' ? [] : [runOnAttached(function (comp, _se) { 12340 detectSize(comp, 4, menuMarkers.item).each(function (_a) { 12341 var numColumns = _a.numColumns, numRows = _a.numRows; 12342 Keying.setGridSize(comp, numRows, numColumns); 12343 }); 12344 })]) 12345 }; 12346 }; 12347 12348 var register$2 = function (editor, sharedBackstage) { 12349 var activeAutocompleter = Cell(Optional.none()); 12350 var processingAction = Cell(false); 12351 var autocompleter = build$1(InlineView.sketch({ 12352 dom: { 12353 tag: 'div', 12354 classes: ['tox-autocompleter'] 12355 }, 12356 components: [], 12357 fireDismissalEventInstead: {}, 12358 inlineBehaviours: derive$1([config('dismissAutocompleter', [run(dismissRequested(), function () { 12359 return cancelIfNecessary(); 12360 })])]), 12361 lazySink: sharedBackstage.getSink 12362 })); 12363 var isMenuOpen = function () { 12364 return InlineView.isOpen(autocompleter); 12365 }; 12366 var isActive = function () { 12367 return activeAutocompleter.get().isSome(); 12368 }; 12369 var hideIfNecessary = function () { 12370 if (isActive()) { 12371 InlineView.hide(autocompleter); 12372 } 12373 }; 12374 var cancelIfNecessary = function () { 12375 if (isActive()) { 12376 var lastElement = activeAutocompleter.get().map(function (ac) { 12377 return ac.element; 12378 }); 12379 detect$4(lastElement.getOr(SugarElement.fromDom(editor.selection.getNode()))).each(unwrap); 12380 hideIfNecessary(); 12381 activeAutocompleter.set(Optional.none()); 12382 processingAction.set(false); 12383 } 12384 }; 12385 var getAutocompleters = cached(function () { 12386 return register(editor); 12387 }); 12388 var getCombinedItems = function (triggerChar, matches) { 12389 var columns = findMap(matches, function (m) { 12390 return Optional.from(m.columns); 12391 }).getOr(1); 12392 return bind(matches, function (match) { 12393 var choices = match.items; 12394 return createAutocompleteItems(choices, match.matchText, function (itemValue, itemMeta) { 12395 var nr = editor.selection.getRng(); 12396 getContext(editor.dom, nr, triggerChar).fold(function () { 12397 return console.error('Lost context. Cursor probably moved'); 12398 }, function (_a) { 12399 var range = _a.range; 12400 var autocompleterApi = { 12401 hide: function () { 12402 cancelIfNecessary(); 12403 }, 12404 reload: function (fetchOptions) { 12405 hideIfNecessary(); 12406 load(fetchOptions); 12407 } 12408 }; 12409 processingAction.set(true); 12410 match.onAction(autocompleterApi, range, itemValue, itemMeta); 12411 processingAction.set(false); 12412 }); 12413 }, columns, ItemResponse$1.BUBBLE_TO_SANDBOX, sharedBackstage, match.highlightOn); 12414 }); 12415 }; 12416 var commenceIfNecessary = function (context) { 12417 if (!isActive()) { 12418 var wrapper = create$4(editor, context.range); 12419 activeAutocompleter.set(Optional.some({ 12420 triggerChar: context.triggerChar, 12421 element: wrapper, 12422 matchLength: context.text.length 12423 })); 12424 processingAction.set(false); 12425 } 12426 }; 12427 var display = function (ac, context, lookupData, items) { 12428 ac.matchLength = context.text.length; 12429 var columns = findMap(lookupData, function (ld) { 12430 return Optional.from(ld.columns); 12431 }).getOr(1); 12432 InlineView.showAt(autocompleter, { 12433 anchor: 'node', 12434 root: SugarElement.fromDom(editor.getBody()), 12435 node: Optional.from(ac.element) 12436 }
12436, Menu.sketch(createMenuFrom(createPartialMenuWithAlloyItems('autocompleter-value', true, items, columns, 'normal'), columns, FocusMode.ContentFocus, 'normal'))); 12437 InlineView.getContent(autocompleter).each(Highlighting.highlightFirst); 12438 }; 12439 var doLookup = function (fetchOptions) { 12440 return activeAutocompleter.get().map(function (ac) { 12441 return getContext(editor.dom, editor.selection.getRng(), ac.triggerChar).bind(function (newContext) { 12442 return lookupWithContext(editor, getAutocompleters, newContext, fetchOptions); 12443 }); 12444 }).getOrThunk(function () { 12445 return lookup(editor, getAutocompleters); 12446 }); 12447 }; 12448 var load = function (fetchOptions) { 12449 doLookup(fetchOptions).fold(cancelIfNecessary, function (lookupInfo) { 12450 commenceIfNecessary(lookupInfo.context); 12451 lookupInfo.lookupData.then(function (lookupData) { 12452 activeAutocompleter.get().map(function (ac) { 12453 var context = lookupInfo.context; 12454 if (ac.triggerChar === context.triggerChar) { 12455 var combinedItems = getCombinedItems(context.triggerChar, lookupData); 12456 if (combinedItems.length > 0) { 12457 display(ac, context, lookupData, combinedItems); 12458 } else if (context.text.length - ac.matchLength >= 10) { 12459 cancelIfNecessary(); 12460 } else { 12461 hideIfNecessary(); 12462 } 12463 } 12464 }); 12465 }); 12466 }); 12467 }; 12468 var onKeypress = last$2(function (e) { 12469 if (e.which === 27) { 12470 return; 12471 } 12472 load(); 12473 }, 50); 12474 var autocompleterUiApi = { 12475 onKeypress: onKeypress, 12476 cancelIfNecessary: cancelIfNecessary, 12477 isMenuOpen: isMenuOpen, 12478 isActive: isActive, 12479 isProcessingAction: processingAction.get, 12480 getView: function () { 12481 return InlineView.getContent(autocompleter); 12482 } 12483 }; 12484 if (editor.hasPlugin('rtc') === false) { 12485 AutocompleterEditorEvents.setup(autocompleterUiApi, editor); 12486 } 12487 }; 12488 var Autocompleter = { register: register$2 }; 12489 12490 var filter$2 = always; 12491 var bind$3 = function (element, event, handler) { 12492 return bind$2(element, event, filter$2, handler); 12493 }; 12494 var capture$1 = function (element, event, handler) { 12495 return capture(element, event, filter$2, handler); 12496 }; 12497 var fromRawEvent$1 = fromRawEvent; 12498 12499 var closest$4 = function (scope, selector, isRoot) { 12500 return closest$3(scope, selector, isRoot).isSome(); 12501 }; 12502 12503 var DelayedFunction = function (fun, delay) { 12504 var ref = null; 12505 var schedule = function () { 12506 var args = []; 12507 for (var _i = 0; _i < arguments.length; _i++) { 12508 args[_i] = arguments[_i]; 12509 } 12510 ref = setTimeout(function () { 12511 fun.apply(null, args); 12512 ref = null; 12513 }, delay); 12514 }; 12515 var cancel = function () { 12516 if (ref !== null) { 12517 clearTimeout(ref); 12518 ref = null; 12519 } 12520 }; 12521 return { 12522 cancel: cancel, 12523 schedule: schedule 12524 }; 12525 }; 12526 12527 var SIGNIFICANT_MOVE = 5; 12528 var LONGPRESS_DELAY = 400; 12529 var getTouch = function (event) { 12530 var raw = event.raw; 12531 if (raw.touches === undefined || raw.touches.length !== 1) { 12532 return Optional.none(); 12533 } 12534 return Optional.some(raw.touches[0]); 12535 }; 12536 var isFarEnough = function (touch, data) { 12537 var distX = Math.abs(touch.clientX - data.x); 12538 var distY = Math.abs(touch.clientY - data.y); 12539 return distX > SIGNIFICANT_MOVE || distY > SIGNIFICANT_MOVE; 12540 }; 12541 var monitor = function (settings) { 12542 var startData = Cell(Optional.none()); 12543 var longpressFired = Cell(false); 12544 var longpress$1 = DelayedFunction(function (event) { 12545 settings.triggerEvent(longpress(), event); 12546 longpressFired.set(true); 12547 }, LONGPRESS_DELAY); 12548 var handleTouchstart = function (event) { 12549 getTouch(event).each(function (touch) { 12550 longpress$1.cancel(); 12551 var data = { 12552 x: touch.clientX, 12553 y: touch.clientY, 12554 target: event.target 12555 }; 12556 longpress$1.schedule(event); 12557 longpressFired.set(false); 12558 startData.set(Optional.some(data)); 12559 }); 12560 return Optional.none(); 12561 }; 12562 var handleTouchmove = function (event) { 12563 longpress$1.cancel(); 12564 getTouch(event).each(function (touch) { 12565 startData.get().each(function (data) { 12566 if (isFarEnough(touch, data)) { 12567 startData.set(Optional.none()); 12568 } 12569 }); 12570 }); 12571 return Optional.none(); 12572 }; 12573 var handleTouchend = function (event) { 12574 longpress$1.cancel(); 12575 var isSame = function (data) { 12576 return eq$1(data.target, event.target); 12577 }; 12578 return startData.get().filter(isSame).map(function (_data) { 12579 if (longpressFired.get()) { 12580 event.prevent(); 12581 return false;
12582 } else { 12583 return settings.triggerEvent(tap(), event); 12584 } 12585 }); 12586 }; 12587 var handlers = wrapAll$1([ 12588 { 12589 key: touchstart(), 12590 value: handleTouchstart 12591 }, 12592 { 12593 key: touchmove(), 12594 value: handleTouchmove 12595 }, 12596 { 12597 key: touchend(), 12598 value: handleTouchend 12599 } 12600 ]); 12601 var fireIfReady = function (event, type) { 12602 return get$1(handlers, type).bind(function (handler) { 12603 return handler(event); 12604 }); 12605 }; 12606 return { fireIfReady: fireIfReady }; 12607 }; 12608 12609 var isDangerous = function (event) { 12610 var keyEv = event.raw; 12611 return keyEv.which === BACKSPACE[0] && !contains([ 12612 'input', 12613 'textarea' 12614 ], name(event.target)) && !closest$4(event.target, '[contenteditable="true"]'); 12615 }; 12616 var isFirefox = function () { 12617 return detect$3().browser.isFirefox(); 12618 }; 12619 var settingsSchema = objOfOnly([ 12620 strictFunction('triggerEvent'), 12621 defaulted$1('stopBackspace', true) 12622 ]); 12623 var bindFocus = function (container, handler) { 12624 if (isFirefox()) { 12625 return capture$1(container, 'focus', handler); 12626 } else { 12627 return bind$3(container, 'focusin', handler); 12628 } 12629 }; 12630 var bindBlur = function (container, handler) { 12631 if (isFirefox()) { 12632 return capture$1(container, 'blur', handler); 12633 } else { 12634 return bind$3(container, 'focusout', handler); 12635 } 12636 }; 12637 var setup$1 = function (container, rawSettings) { 12638 var settings = asRawOrDie('Getting GUI events settings', settingsSchema, rawSettings); 12639 var pointerEvents = [ 12640 'touchstart', 12641 'touchmove', 12642 'touchend', 12643 'touchcancel', 12644 'gesturestart', 12645 'mousedown', 12646 'mouseup', 12647 'mouseover', 12648 'mousemove', 12649 'mouseout', 12650 'click' 12651 ]; 12652 var tapEvent = monitor(settings); 12653 var simpleEvents = map(pointerEvents.concat([ 12654 'selectstart', 12655 'input', 12656 'contextmenu', 12657 'change', 12658 'transitionend', 12659 'drag', 12660 'dragstart', 12661 'dragend', 12662 'dragenter', 12663 'dragleave', 12664 'dragover', 12665 'drop', 12666 'keyup' 12667 ]), function (type) { 12668 return bind$3(container, type, function (event) { 12669 tapEvent.fireIfReady(event, type).each(function (tapStopped) { 12670 if (tapStopped) { 12671 event.kill(); 12672 } 12673 }); 12674 var stopped = settings.triggerEvent(type, event); 12675 if (stopped) { 12676 event.kill(); 12677 } 12678 }); 12679 }); 12680 var pasteTimeout = Cell(Optional.none()); 12681 var onPaste = bind$3(container, 'paste', function (event) { 12682 tapEvent.fireIfReady(event, 'paste').each(function (tapStopped) { 12683 if (tapStopped) { 12684 event.kill(); 12685 } 12686 }); 12687 var stopped = settings.triggerEvent('paste', event); 12688 if (stopped) { 12689 event.kill(); 12690 } 12691 pasteTimeout.set(Optional.some(setTimeout(function () { 12692 settings.triggerEvent(postPaste(), event); 12693 }, 0))); 12694 }); 12695 var onKeydown = bind$3(container, 'keydown', function (event) { 12696 var stopped = settings.triggerEvent('keydown', event); 12697 if (stopped) { 12698 event.kill(); 12699 } else if (settings.stopBackspace === true && isDangerous(event)) { 12700 event.prevent(); 12701 } 12702 }); 12703 var onFocusIn = bindFocus(container, function (event) { 12704 var stopped = settings.triggerEvent('focusin', event); 12705 if (stopped) { 12706 event.kill(); 12707 } 12708 }); 12709 var focusoutTimeout = Cell(Optional.none()); 12710 var onFocusOut = bindBlur(container, function (event) { 12711 var stopped = settings.triggerEvent('focusout', event); 12712 if (stopped) { 12713 event.kill(); 12714 } 12715 focusoutTimeout.set(Optional.some(setTimeout(function () { 12716 settings.triggerEvent(postBlur(), event); 12717 }, 0))); 12718 }); 12719 var unbind = function () { 12720 each(simpleEvents, function (e) { 12721 e.unbind(); 12722 }); 12723 onKeydown.unbind(); 12724 onFocusIn.unbind(); 12725 onFocusOut.unbind(); 12726 onPaste.unbind(); 12727 pasteTimeout.get().each(clearTimeout); 12728 focusoutTimeout.get().each(clearTimeout); 12729 }; 12730 return { unbind: unbind }; 12731 }; 12732 12733 var derive$2 = function (rawEvent, rawTarget) { 12734 var source = get$1(rawEvent, 'target').getOr(rawTarget); 12735 return Cell(source); 12736 }; 12737 12738 var fromSource = function (event, source) { 12739 var stopper = Cell(false); 12740 var cutter = Cell(false); 12741 var stop = function () { 12742 stopper.set(true); 12743 }; 12744 var cut = function () { 12745 cutter.set(true); 12746 }; 12747 return { 12748 stop: stop, 12749 cut: cut, 12750 isStopped: stopper.get, 12751 isCut: cutter.get, 12752 event: event, 12753 setSource: source.set, 12754 getSource: source.get 12755 }; 12756 }; 12757 var fromExternal = function (event) { 12758 var stopper = Cell(false); 12759 var stop = function () { 12760 stopper.set(true); 12761 }; 12762 return { 12763 stop: stop, 12764 cut: noop, 12765 isStopped: stopper.get, 12766 isCut: never, 12767 event: event, 12768 setSource: die('Cannot set source of a broadcasted event'), 12769 getSource: die('Cannot get source of a broadcasted event') 12770 }; 12771 }; 12772 12773 var adt$b = Adt.generate([ 12774 { stopped: [] }, 12775 { resume: ['element'] }, 12776 { complete: [] } 12777 ]); 12778 var doTriggerHandler = function (lookup, eventType, rawEvent, target, source, logger) { 12779 var handler = lookup(eventType, target); 12780 var simulatedEvent = fromSource(rawEvent, source); 12781 return handler.fold(function () { 12782 logger.logEventNoHandlers(eventType, target); 12783 return adt$b.complete(); 12784 }, function (handlerInfo) { 12785 var descHandler = handlerInfo.descHandler; 12786 var eventHandler = getCurried(descHandler); 12787 eventHandler(simulatedEvent); 12788 if (simulatedEvent.isStopped()) { 12789 logger.logEventStopped(eventType, handlerInfo.element, descHandler.purpose); 12790 return adt$b.stopped(); 12791 } else if (simulatedEvent.isCut()) { 12792 logger.logEventCut(eventType, handlerInfo.element, descHandler.purpose); 12793 return adt$b.complete(); 12794 } else { 12795 return parent(handlerInfo.element).fold(function () { 12796 logger.logNoParent(eventType, handlerInfo.element, descHandler.purpose); 12797 return adt$b.complete(); 12798 }, function (parent) { 12799 logger.logEventResponse(eventType, handlerInfo.element, descHandler.purpose); 12800 return adt$b.resume(parent); 12801 }); 12802 } 12803 }); 12804 }; 12805 var doTriggerOnUntilStopped = function (lookup, eventType, rawEvent, rawTarget, source, logger) { 12806 return doTriggerHandler(lookup, eventType, rawEvent, rawTarget, source, logger).fold(always, function (parent) { 12807 return doTriggerOnUntilStopped(lookup, eventType, rawEvent, parent, source, logger); 12808 }, never); 12809 }; 12810 var triggerHandler = function (lookup, eventType, rawEvent, target, logger) { 12811 var source = derive$2(rawEvent, target); 12812 return doTriggerHandler(lookup, eventType, rawEvent, target, source, logger); 12813 }; 12814 var broadcast = function (listeners, rawEvent, _logger) { 12815 var simulatedEvent = fromExternal(rawEvent); 12816 each(listeners, function (listener) { 12817 var descHandler = listener.descHandler; 12818 var handler = getCurried(descHandler); 12819 handler(simulatedEvent); 12820 }); 12821 return simulatedEvent.isStopped(); 12822 }; 12823 var triggerUntilStopped = function (lookup, eventType, rawEvent, logger) { 12824 return triggerOnUntilStopped(lookup, eventType, rawEvent, rawEvent.target, logger); 12825 }; 12826 var triggerOnUntilStopped = function (lookup, eventType, rawEvent, rawTarget, logger) { 12827 var source = derive$2(rawEvent, rawTarget); 12828 return doTriggerOnUntilStopped(lookup, eventType, rawEvent, rawTarget, source, logger); 12829 }; 12830 12831 var eventHandler = function (element, descHandler) { 12832 return { 12833 element: element, 12834 descHandler: descHandler 12835 }; 12836 }; 12837 var broadcastHandler = function (id, handler) { 12838 return { 12839 id: id, 12840 descHandler: handler 12841 }; 12842 }; 12843 var EventRegistry = function () { 12844 var registry = {}; 12845 var registerId = function (extraArgs, id, events) { 12846 each$1(events, function (v, k) { 12847 var handlers = registry[k] !== undefined ? registry[k] : {}; 12848 handlers[id] = curryArgs(v, extraArgs); 12849 registry[k] = handlers; 12850 }); 12851 }; 12852 var findHandler = function (handlers, elem) { 12853 return read$1(elem).fold(function () { 12854 return Optional.none(); 12855 }, function (id) { 12856 return handlers.bind(function (h) { 12857 return get$1(h, id); 12858 }).map(function (descHandler) { 12859 return eventHandler(elem, descHandler); 12860 }); 12861 }); 12862 }; 12863 var filterByType = function (type) { 12864 return get$1(registry, type).map(function (handlers) { 12865 return mapToArray(handlers, function (f, id) { 12866 return broadcastHandler(id, f); 12867 }); 12868 }).getOr([]); 12869 }; 12870 var find = function (isAboveRoot, type, target) { 12871 var handlers = get$1(registry, type); 12872 return closest(target, function (elem) { 12873 return findHandler(handlers, elem); 12874 }, isAboveRoot); 12875 }; 12876 var unregisterId = function (id) { 12877 each$1(registry, function (handlersById, _eventName) { 12878 if (handlersById.hasOwnProperty(id)) { 12879 delete handlersById[id]; 12880 } 12881 }); 12882 }; 12883 return { 12884 registerId: registerId, 12885 unregisterId: unregisterId, 12886 filterByType: filterByType, 12887 find: find 12888 }; 12889 }; 12890 12891 var Registry = function () { 12892 var events = EventRegistry(); 12893 var components = {}; 12894 var readOrTag = function (component) { 12895 var elem = component.element; 12896 return read$1(elem).fold(function () { 12897 return write('uid-', component.element); 12898 }, function (uid) { 12899 return uid; 12900 }); 12901 }; 12902 var failOnDuplicate = function (component, tagId) { 12903 var conflict = components[tagId]; 12904 if (conflict === component) { 12905 unregister(component); 12906 } else { 12907 throw new Error('The tagId "' + tagId + '" is already used by: ' + element(conflict.element) + '\nCannot use it for: ' + element(component.element) + '\n' + 'The conflicting element is' + (inBody(conflict.element) ? ' ' : ' not ') + 'already in the DOM'); 12908 } 12909 }; 12910 var register = function (component) { 12911 var tagId = readOrTag(component); 12912 if (hasNonNullableKey(components, tagId)) { 12913 failOnDuplicate(component, tagId); 12914 } 12915 var extraArgs = [component]; 12916 events.registerId(extraArgs, tagId, component.events); 12917 components[tagId] = component; 12918 }; 12919 var unregister = function (component) { 12920 read$1(component.element).each(function (tagId) { 12921 delete components[tagId]; 12922 events.unregisterId(tagId); 12923 }); 12924 }; 12925 var filter = function (type) { 12926 return events.filterByType(type); 12927 }; 12928 var find = function (isAboveRoot, type, target) { 12929 return events.find(isAboveRoot, type, target); 12930 }; 12931 var getById = function (id) { 12932 return get$1(components, id); 12933 }; 12934 return { 12935 find: find, 12936 filter: filter, 12937 register: register, 12938 unregister: unregister, 12939 getById: getById 12940 }; 12941 }; 12942 12943 var factory$3 = function (detail) { 12944 var _a = detail.dom, attributes = _a.attributes, domWithoutAttributes = __rest(_a, ['attributes']); 12945 return { 12946 uid: detail.uid, 12947 dom: __assign({ 12948 tag: 'div', 12949 attributes: __assign({ role: 'presentation' }, attributes) 12950 }, domWithoutAttributes), 12951 components: detail.components, 12952 behaviours: get$d(detail.containerBehaviours), 12953 events: detail.events, 12954 domModification: detail.domModification, 12955 eventOrder: detail.eventOrder 12956 }; 12957 }; 12958 var Container = single$2({ 12959 name: 'Container', 12960 factory: factory$3, 12961 configFields: [ 12962 defaulted$1('components', []), 12963 field$1('containerBehaviours', []), 12964 defaulted$1('events', {}), 12965 defaulted$1('domModification', {}), 12966 defaulted$1('eventOrder', {}) 12967 ] 12968 }); 12969 12970 var takeover = function (root) { 12971 var isAboveRoot = function (el) { 12972 return parent(root.element).fold(always, function (parent) { 12973 return eq$1(el, parent); 12974 }); 12975 }; 12976 var registry = Registry(); 12977 var lookup = function (eventName, target) { 12978 return registry.find(isAboveRoot, eventName, target); 12979 }; 12980 var domEvents = setup$1(root.element, { 12981 triggerEvent: function (eventName, event) { 12982 return monitorEvent(eventName, event.target, function (logger) { 12983 return triggerUntilStopped(lookup, eventName, event, logger); 12984 }); 12985 } 12986 }); 12987 var systemApi = { 12988 debugInfo: constant('real'), 12989 triggerEvent: function (eventName, target, data) { 12990 monitorEvent(eventName, target, function (logger) { 12991 return triggerOnUntilStopped(lookup, eventName, data, target, logger); 12992 }); 12993 }, 12994 triggerFocus: function (target, originator) { 12995 read$1(target).fold(function () { 12996 focus$1(target); 12997 }, function (_alloyId) { 12998 monitorEvent(focus(), target, function (logger) { 12999 triggerHandler(lookup, focus(), { 13000 originator: originator, 13001 kill: noop, 13002 prevent: noop, 13003 target: target 13004 }, target, logger); 13005 return false;
13006 }); 13007 }); 13008 }, 13009 triggerEscape: function (comp, simulatedEvent) { 13010 systemApi.triggerEvent('keydown', comp.element, simulatedEvent.event); 13011 }, 13012 getByUid: function (uid) { 13013 return getByUid(uid); 13014 }, 13015 getByDom: function (elem) { 13016 return getByDom(elem); 13017 }, 13018 build: build$1, 13019 addToGui: function (c) { 13020 add(c); 13021 }, 13022 removeFromGui: function (c) { 13023 remove$1(c); 13024 }, 13025 addToWorld: function (c) { 13026 addToWorld(c); 13027 }, 13028 removeFromWorld: function (c) { 13029 removeFromWorld(c); 13030 }, 13031 broadcast: function (message) { 13032 broadcast$1(message); 13033 }, 13034 broadcastOn: function (channels, message) { 13035 broadcastOn(channels, message); 13036 }, 13037 broadcastEvent: function (eventName, event) { 13038 broadcastEvent(eventName, event); 13039 }, 13040 isConnected: always 13041 }; 13042 var addToWorld = function (component) { 13043 component.connect(systemApi); 13044 if (!isText(component.element)) { 13045 registry.register(component); 13046 each(component.components(), addToWorld); 13047 systemApi.triggerEvent(systemInit(), component.element, { target: component.element }); 13048 } 13049 }; 13050 var removeFromWorld = function (component) { 13051 if (!isText(component.element)) { 13052 each(component.components(), removeFromWorld); 13053 registry.unregister(component); 13054 } 13055 component.disconnect(); 13056 }; 13057 var add = function (component) { 13058 attach$1(root, component); 13059 }; 13060 var remove$1 = function (component) { 13061 detach(component); 13062 }; 13063 var destroy = function () { 13064 domEvents.unbind(); 13065 remove(root.element); 13066 }; 13067 var broadcastData = function (data) { 13068 var receivers = registry.filter(receive()); 13069 each(receivers, function (receiver) { 13070 var descHandler = receiver.descHandler; 13071 var handler = getCurried(descHandler); 13072 handler(data); 13073 }); 13074 }; 13075 var broadcast$1 = function (message) { 13076 broadcastData({ 13077 universal: true, 13078 data: message 13079 }); 13080 }; 13081 var broadcastOn = function (channels, message) { 13082 broadcastData({ 13083 universal: false, 13084 channels: channels, 13085 data: message 13086 }); 13087 }; 13088 var broadcastEvent = function (eventName, event) { 13089 var listeners = registry.filter(eventName); 13090 return broadcast(listeners, event); 13091 }; 13092 var getByUid = function (uid) { 13093 return registry.getById(uid).fold(function () { 13094 return Result.error(new Error('Could not find component with uid: "' + uid + '" in system.')); 13095 }, Result.value); 13096 }; 13097 var getByDom = function (elem) { 13098 var uid = read$1(elem).getOr('not found'); 13099 return getByUid(uid); 13100 }; 13101 addToWorld(root); 13102 return { 13103 root: root, 13104 element: root.element, 13105 destroy: destroy, 13106 add: add, 13107 remove: remove$1, 13108 getByUid: getByUid, 13109 getByDom: getByDom, 13110 addToWorld: addToWorld, 13111 removeFromWorld: removeFromWorld, 13112 broadcast: broadcast$1, 13113 broadcastOn: broadcastOn, 13114 broadcastEvent: broadcastEvent 13115 }; 13116 }; 13117 13118 var renderBar = function (spec, backstage) { 13119 return { 13120 dom: { 13121 tag: 'div', 13122 classes: [ 13123 'tox-bar', 13124 'tox-form__controls-h-stack' 13125 ] 13126 }, 13127 components: map(spec.items, backstage.interpreter) 13128 }; 13129 }; 13130 13131 var schema$e = constant([ 13132 defaulted$1('prefix', 'form-field'), 13133 field$1('fieldBehaviours', [ 13134 Composing, 13135 Representing 13136 ]) 13137 ]); 13138 var parts$3 = constant([ 13139 optional({ 13140 schema: [strict$1('dom')], 13141 name: 'label' 13142 }), 13143 optional({ 13144 factory: { 13145 sketch: function (spec) { 13146 return { 13147 uid: spec.uid, 13148 dom: { 13149 tag: 'span', 13150 styles: { display: 'none' }, 13151 attributes: { 'aria-hidden': 'true' }, 13152 innerHtml: spec.text 13153 } 13154 }; 13155 } 13156 }, 13157 schema: [strict$1('text')], 13158 name: 'aria-descriptor' 13159 }), 13160 required({ 13161 factory: { 13162 sketch: function (spec) { 13163 var excludeFactory = exclude$1(spec, ['factory']); 13164 return spec.factory.sketch(excludeFactory); 13165 } 13166 }, 13167 schema: [strict$1('factory')], 13168 name: 'field' 13169 }) 13170 ]); 13171 13172 var factory$4 = function (detail, components, _spec, _externals) { 13173 var behaviours = augment(detail.fieldBehaviours, [ 13174 Composing.config({ 13175 find: function (container) { 13176 return getPart(container, detail, 'field'); 13177 } 13178 }), 13179 Representing.config({ 13180 store: { 13181 mode: 'manual', 13182 getValue: function (field) { 13183 return Composing.getCurrent(field).bind(Representing.getValue); 13184 }, 13185 setValue: function (field, value) { 13186 Composing.getCurrent(field).each(function (current) { 13187 Representing.setValue(current, value); 13188 }); 13189 } 13190 } 13191 }) 13192 ]); 13193 var events = derive([runOnAttached(function (component, _simulatedEvent) { 13194 var ps = getParts(component, detail, [ 13195 'label', 13196 'field', 13197 'aria-descriptor' 13198 ]); 13199 ps.field().each(function (field) { 13200 var id = generate$1(detail.prefix); 13201 ps.label().each(function (label) { 13202 set$1(label.element, 'for', id); 13203 set$1(field.element, 'id', id); 13204 }); 13205 ps['aria-descriptor']().each(function (descriptor) { 13206 var descriptorId = generate$1(detail.prefix); 13207 set$1(descriptor.element, 'id', descriptorId); 13208 set$1(field.element, 'aria-describedby', descriptorId); 13209 }); 13210 }); 13211 })]); 13212 var apis = { 13213 getField: function (container) { 13214 return getPart(container, detail, 'field'); 13215 }, 13216 getLabel: function (container) { 13217 return getPart(container, detail, 'label'); 13218 } 13219 }; 13220 return { 13221 uid: detail.uid, 13222 dom: detail.dom, 13223 components: components, 13224 behaviours: behaviours, 13225 events: events, 13226 apis: apis 13227 }; 13228 }; 13229 var FormField = composite$1({ 13230 name: 'FormField', 13231 configFields: schema$e(), 13232 partFields: parts$3(), 13233 factory: factory$4, 13234 apis: { 13235 getField: function (apis, comp) { 13236 return apis.getField(comp); 13237 }, 13238 getLabel: function (apis, comp) { 13239 return apis.getLabel(comp); 13240 } 13241 } 13242 }); 13243 13244 var exhibit$4 = function (base, tabConfig) { 13245 return nu$6({ 13246 attributes: wrapAll$1([{ 13247 key: tabConfig.tabAttr, 13248 value: 'true' 13249 }]) 13250 }); 13251 }; 13252 13253 var ActiveTabstopping = /*#__PURE__*/Object.freeze({ 13254 __proto__: null, 13255 exhibit: exhibit$4 13256 }); 13257 13258 var TabstopSchema = [defaulted$1('tabAttr', 'data-alloy-tabstop')]; 13259 13260 var Tabstopping = create$1({ 13261 fields: TabstopSchema, 13262 name: 'tabstopping', 13263 active: ActiveTabstopping 13264 }); 13265 13266 var global$a = tinymce.util.Tools.resolve('tinymce.html.Entities'); 13267 13268 var renderFormFieldWith = function (pLabel, pField, extraClasse
13268s, extraBehaviours) { 13269 var spec = renderFormFieldSpecWith(pLabel, pField, extraClasses, extraBehaviours); 13270 return FormField.sketch(spec); 13271 }; 13272 var renderFormField = function (pLabel, pField) { 13273 return renderFormFieldWith(pLabel, pField, [], []); 13274 }; 13275 var renderFormFieldSpecWith = function (pLabel, pField, extraClasses, extraBehaviours) { 13276 return { 13277 dom: renderFormFieldDomWith(extraClasses), 13278 components: pLabel.toArray().concat([pField]), 13279 fieldBehaviours: derive$1(extraBehaviours) 13280 }; 13281 }; 13282 var renderFormFieldDom = function () { 13283 return renderFormFieldDomWith([]); 13284 }; 13285 var renderFormFieldDomWith = function (extraClasses) { 13286 return { 13287 tag: 'div', 13288 classes: ['tox-form__group'].concat(extraClasses) 13289 }; 13290 }; 13291 var renderLabel = function (label, providersBackstage) { 13292 return FormField.parts.label({ 13293 dom: { 13294 tag: 'label', 13295 classes: ['tox-label'], 13296 innerHtml: providersBackstage.translate(label) 13297 } 13298 }); 13299 }; 13300 13301 var formChangeEvent = generate$1('form-component-change'); 13302 var formCloseEvent = generate$1('form-close'); 13303 var formCancelEvent = generate$1('form-cancel'); 13304 var formActionEvent = generate$1('form-action'); 13305 var formSubmitEvent = generate$1('form-submit'); 13306 var formBlockEvent = generate$1('form-block'); 13307 var formUnblockEvent = generate$1('form-unblock'); 13308 var formTabChangeEvent = generate$1('form-tabchange'); 13309 var formResizeEvent = generate$1('form-resize'); 13310 13311 var renderCollection = function (spec, providersBackstage) { 13312 var _a; 13313 var pLabel = spec.label.map(function (label) { 13314 return renderLabel(label, providersBackstage); 13315 }); 13316 var runOnItem = function (f) { 13317 return function (comp, se) { 13318 closest$3(se.event.target, '[data-collection-item-value]').each(function (target) { 13319 f(comp, se, target, get$3(target, 'data-collection-item-value')); 13320 }); 13321 }; 13322 }; 13323 var setContents = function (comp, items) { 13324 var htmlLines = map(items, function (item) { 13325 var itemText = global$6.translate(item.text); 13326 var textContent = spec.columns === 1 ? '<div class="tox-collection__item-label">' + itemText + '</div>' : ''; 13327 var iconContent = '<div class="tox-collection__item-icon">' + item.icon + '</div>'; 13328 var mapItemName = { 13329 '_': ' ', 13330 ' - ': ' ', 13331 '-': ' ' 13332 }; 13333 var ariaLabel = itemText.replace(/\_| \- |\-/g, function (match) { 13334 return mapItemName[match]; 13335 }); 13336 var disabledClass = providersBackstage.isDisabled() ? ' tox-collection__item--state-disabled' : ''; 13337 return '<div class="tox-collection__item' + disabledClass + '" tabindex="-1" data-collection-item-value="' + global$a.encodeAllRaw(item.value) + '" title="' + ariaLabel + '" aria-label="' + ariaLabel + '">' + iconContent + textContent + '</div>'; 13338 }); 13339 var chunks = spec.columns !== 'auto' && spec.columns > 1 ? chunk(htmlLines, spec.columns) : [htmlLines]; 13340 var html = map(chunks, function (ch) { 13341 return '<div class="tox-collection__group">' + ch.join('') + '</div>'; 13342 }); 13343 set(comp.element, html.join('')); 13344 }; 13345 var onClick = runOnItem(function (comp, se, tgt, itemValue) { 13346 se.stop(); 13347 if (!providersBackstage.isDisabled()) { 13348 emitWith(comp, formActionEvent, { 13349 name: spec.name, 13350 value: itemValue 13351 }); 13352 } 13353 }); 13354 var collectionEvents = [ 13355 run(mouseover(), runOnItem(function (comp, se, tgt) { 13356 focus$1(tgt); 13357 })), 13358 run(click(), onClick), 13359 run(tap(), onClick), 13360 run(focusin(), runOnItem(function (comp, se, tgt) { 13361 descendant$1(comp.element, '.' + activeClass).each(function (currentActive) { 13362 remove$4(currentActive, activeClass); 13363 }); 13364 add$2(tgt, activeClass); 13365 })), 13366 run(focusout(), runOnItem(function (comp) { 13367 descendant$1(comp.element, '.' + activeClass).each(function (currentActive) { 13368 remove$4(currentActive, activeClass); 13369 }); 13370 })), 13371 runOnExecute(runOnItem(function (comp, se, tgt, itemValue) { 13372 emitWith(comp, formActionEvent, { 13373 name: spec.name, 13374 value: itemValue 13375 }); 13376 })) 13377 ]; 13378 var iterCollectionItems = function (comp, applyAttributes) { 13379 return map(descendants(comp.element, '.tox-collection__item'), applyAttributes); 13380 }; 13381 var pField = FormField.parts.field({ 13382 dom: { 13383 tag: 'div',
13384 classes: ['tox-collection'].concat(spec.columns !== 1 ? ['tox-collection--grid'] : ['tox-collection--list']) 13385 }, 13386 components: [], 13387 factory: { sketch: identity }, 13388 behaviours: derive$1([ 13389 Disabling.config({ 13390 disabled: providersBackstage.isDisabled, 13391 onDisabled: function (comp) { 13392 iterCollectionItems(comp, function (childElm) { 13393 add$2(childElm, 'tox-collection__item--state-disabled'); 13394 set$1(childElm, 'aria-disabled', true); 13395 }); 13396 }, 13397 onEnabled: function (comp) { 13398 iterCollectionItems(comp, function (childElm) { 13399 remove$4(childElm, 'tox-collection__item--state-disabled'); 13400 remove$1(childElm, 'aria-disabled'); 13401 }); 13402 } 13403 }), 13404 receivingConfig(), 13405 Replacing.config({}), 13406 Representing.config({ 13407 store: { 13408 mode: 'memory', 13409 initialValue: [] 13410 }, 13411 onSetValue: function (comp, items) { 13412 setContents(comp, items);
13413 if (spec.columns === 'auto') { 13414 detectSize(comp, 5, 'tox-collection__item').each(function (_a) { 13415 var numRows = _a.numRows, numColumns = _a.numColumns; 13416 Keying.setGridSize(comp, numRows, numColumns); 13417 }); 13418 } 13419 emit(comp, formResizeEvent); 13420 } 13421 }), 13422 Tabstopping.config({}), 13423 Keying.config(deriveCollectionMovement(spec.columns, 'normal')), 13424 config('collection-events', collectionEvents) 13425 ]), 13426 eventOrder: (_a = {}, _a[execute()] = [ 13427 'disabling', 13428 'alloy.base.behaviour', 13429 'collection-events' 13430 ], _a) 13431 }); 13432 var extraClasses = ['tox-form__group--collection']; 13433 return renderFormFieldWith(pLabel, pField, extraClasses, []); 13434 }; 13435 13436 var schema$f = constant([ 13437 option('data'), 13438 defaulted$1('inputAttributes', {}), 13439 defaulted$1('inputStyles', {}), 13440 defaulted$1('tag', 'input'), 13441 defaulted$1('inputClasses', []), 13442 onHandler('onSetValue'), 13443 defaulted$1('styles', {}), 13444 defaulted$1('eventOrder', {}), 13445 field$1('inputBehaviours', [ 13446 Representing, 13447 Focusing 13448 ]), 13449 defaulted$1('selectOnFocus', true) 13450 ]); 13451 var focusBehaviours = function (detail) { 13452 return derive$1([Focusing.config({ 13453 onFocus: !detail.selectOnFocus ? noop : function (component) { 13454 var input = component.element; 13455 var value = get$6(input); 13456 input.dom.setSelectionRange(0, value.length); 13457 } 13458 })]); 13459 }; 13460 var behaviours = function (detail) { 13461 return __assign(__assign({}, focusBehaviours(detail)), augment(detail.inputBehaviours, [Representing.config({ 13462 store: __assign(__assign({ mode: 'manual' }, detail.data.map(function (data) { 13463 return { initialValue: data }; 13464 }).getOr({})), { 13465 getValue: function (input) { 13466 return get$6(input.element); 13467 }, 13468 setValue: function (input, data) { 13469 var current = get$6(input.element); 13470 if (current !== data) { 13471 set$3(input.element, data); 13472 } 13473 } 13474 }), 13475 onSetValue: detail.onSetValue 13476 })])); 13477 }; 13478 var dom$2 = function (detail) { 13479 return { 13480 tag: detail.tag, 13481 attributes: __assign({ type: 'text' }, detail.inputAttributes), 13482 styles: detail.inputStyles, 13483 classes: detail.inputClasses 13484 }; 13485 }; 13486 13487 var factory$5 = function (detail, _spec) { 13488 return { 13489 uid: detail.uid, 13490 dom: dom$2(detail), 13491 components: [], 13492 behaviours: behaviours(detail), 13493 eventOrder: detail.eventOrder 13494 }; 13495 }; 13496 var Input = single$2({ 13497 name: 'Input', 13498 configFields: schema$f(), 13499 factory: factory$5 13500 }); 13501 13502 var exports$1 = {}, module = { exports: exports$1 }; 13503 (function (define, exports, module, require) { 13504 (function (f) { 13505 if (typeof exports === 'object' && typeof module !== 'undefined') { 13506 module.exports = f(); 13507 } else if (typeof define === 'function' && define.amd) { 13508 define([], f); 13509 } else { 13510 var g; 13511 if (typeof window !== 'undefined') { 13512 g = window; 13513 } else if (typeof global !== 'undefined') { 13514 g = global; 13515 } else if (typeof self !== 'undefined') { 13516 g = self; 13517 } else { 13518 g = this; 13519 } 13520 g.EphoxContactWrapper = f(); 13521 } 13522 }(function () { 13523 return function () { 13524 function r(e, n, t) { 13525 function o(i, f) { 13526 if (!n[i]) { 13527 if (!e[i]) { 13528 var c = 'function' == typeof require && require; 13529 if (!f && c) 13530 return c(i, !0); 13531 if (u) 13532 return u(i, !0); 13533 var a = new Error('Cannot find module \'' + i + '\''); 13534 throw a.code = 'MODULE_NOT_FOUND', a; 13535 } 13536 var p = n[i] = { exports: {} }; 13537 e[i][0].call(p.exports, function (r) { 13538 var n = e[i][1][r]; 13539 return o(n || r); 13540 }, p, p.exports, r, e, n, t); 13541 } 13542 return n[i].exports; 13543 } 13544 for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++) 13545 o(t[i]); 13546 return o; 13547 } 13548 return r; 13549 }()({ 13550 1: [
vendor: 5,915 bytes, lines 13551-13711
13551 function (require, module, exports) { 13552 var process = module.exports = {}; 13553 var cachedSetTimeout; 13554 var cachedClearTimeout; 13555 function defaultSetTimout() { 13556 throw new Error('setTimeout has not been defined'); 13557 } 13558 function defaultClearTimeout() { 13559 throw new Error('clearTimeout has not been defined'); 13560 } 13561 (function () { 13562 try { 13563 if (typeof setTimeout === 'function') { 13564 cachedSetTimeout = setTimeout; 13565 } else { 13566 cachedSetTimeout = defaultSetTimout; 13567 } 13568 } catch (e) { 13569 cachedSetTimeout = defaultSetTimout; 13570 } 13571 try { 13572 if (typeof clearTimeout === 'function') { 13573 cachedClearTimeout = clearTimeout; 13574 } else { 13575 cachedClearTimeout = defaultClearTimeout; 13576 } 13577 } catch (e) { 13578 cachedClearTimeout = defaultClearTimeout; 13579 } 13580 }()); 13581 function runTimeout(fun) { 13582 if (cachedSetTimeout === setTimeout) { 13583 return setTimeout(fun, 0); 13584 } 13585 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 13586 cachedSetTimeout = setTimeout; 13587 return setTimeout(fun, 0); 13588 } 13589 try { 13590 return cachedSetTimeout(fun, 0); 13591 } catch (e) { 13592 try { 13593 return cachedSetTimeout.call(null, fun, 0); 13594 } catch (e) { 13595 return cachedSetTimeout.call(this, fun, 0); 13596 } 13597 } 13598 } 13599 function runClearTimeout(marker) { 13600 if (cachedClearTimeout === clearTimeout) { 13601 return clearTimeout(marker); 13602 } 13603 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 13604 cachedClearTimeout = clearTimeout; 13605 return clearTimeout(marker); 13606 } 13607 try { 13608 return cachedClearTimeout(marker); 13609 } catch (e) { 13610 try { 13611 return cachedClearTimeout.call(null, marker); 13612 } catch (e) { 13613 return cachedClearTimeout.call(this, marker); 13614 } 13615 } 13616 } 13617 var queue = []; 13618 var draining = false; 13619 var currentQueue; 13620 var queueIndex = -1; 13621 function cleanUpNextTick() { 13622 if (!draining || !currentQueue) { 13623 return; 13624 } 13625 draining = false; 13626 if (currentQueue.length) { 13627 queue = currentQueue.concat(queue); 13628 } else { 13629 queueIndex = -1; 13630 } 13631 if (queue.length) { 13632 drainQueue(); 13633 } 13634 } 13635 function drainQueue() { 13636 if (draining) { 13637 return; 13638 } 13639 var timeout = runTimeout(cleanUpNextTick); 13640 draining = true; 13641 var len = queue.length; 13642 while (len) { 13643 currentQueue = queue; 13644 queue = []; 13645 while (++queueIndex < len) { 13646 if (currentQueue) { 13647 currentQueue[queueIndex].run(); 13648 } 13649 } 13650 queueIndex = -1; 13651 len = queue.length; 13652 } 13653 currentQueue = null; 13654 draining = false; 13655 runClearTimeout(timeout); 13656 } 13657 process.nextTick = function (fun) { 13658 var args = new Array(arguments.length - 1); 13659 if (arguments.length > 1) { 13660 for (var i = 1; i < arguments.length; i++) { 13661 args[i - 1] = arguments[i]; 13662 } 13663 } 13664 queue.push(new Item(fun, args)); 13665 if (queue.length === 1 && !draining) { 13666 runTimeout(drainQueue); 13667 } 13668 }; 13669 function Item(fun, array) { 13670 this.fun = fun; 13671 this.array = array; 13672 } 13673 Item.prototype.run = function () { 13674 this.fun.apply(null, this.array); 13675 }; 13676 process.title = 'browser'; 13677 process.browser = true; 13678 process.env = {}; 13679 process.argv = []; 13680 process.version = ''; 13681 process.versions = {}; 13682 function noop() { 13683 } 13684 process.on = noop; 13685 process.addListener = noop; 13686 process.once = noop; 13687 process.off = noop; 13688 process.removeListener = noop; 13689 process.removeAllListeners = noop; 13690 process.emit = noop; 13691 process.prependListener = noop; 13692 process.prependOnceListener = noop; 13693 process.listeners = function (name) { 13694 return []; 13695 }; 13696 process.binding = function (name) { 13697 throw new Error('process.binding is not supported'); 13698 }; 13699 process.cwd = function () { 13700 return '/'; 13701 }; 13702 process.chdir = function (dir) { 13703 throw new Error('process.chdir is not supported'); 13704 }; 13705 process.umask = function () { 13706 return 0; 13707 }; 13708 }, 13709 {} 13710 ], 13711 2: [
vendor: 4,209 bytes, lines 13712-13806
13712 function (require, module, exports) { 13713 (function (setImmediate) { 13714 (function (root) { 13715 var setTimeoutFunc = setTimeout; 13716 function noop() { 13717 } 13718 function bind(fn, thisArg) { 13719 return function () { 13720 fn.apply(thisArg, arguments); 13721 }; 13722 } 13723 function Promise(fn) { 13724 if (typeof this !== 'object') 13725 throw new TypeError('Promises must be constructed via new'); 13726 if (typeof fn !== 'function') 13727 throw new TypeError('not a function'); 13728 this._state = 0; 13729 this._handled = false; 13730 this._value = undefined; 13731 this._deferreds = []; 13732 doResolve(fn, this); 13733 } 13734 function handle(self, deferred) { 13735 while (self._state === 3) { 13736 self = self._value; 13737 } 13738 if (self._state === 0) { 13739 self._deferreds.push(deferred); 13740 return; 13741 } 13742 self._handled = true; 13743 Promise._immediateFn(function () { 13744 var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected; 13745 if (cb === null) { 13746 (self._state === 1 ? resolve : reject)(deferred.promise, self._value); 13747 return; 13748 } 13749 var ret; 13750 try { 13751 ret = cb(self._value); 13752 } catch (e) { 13753 reject(deferred.promise, e); 13754 return; 13755 } 13756 resolve(deferred.promise, ret); 13757 }); 13758 } 13759 function resolve(self, newValue) { 13760 try { 13761 if (newValue === self) 13762 throw new TypeError('A promise cannot be resolved with itself.'); 13763 if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) { 13764 var then = newValue.then; 13765 if (newValue instanceof Promise) { 13766 self._state = 3; 13767 self._value = newValue; 13768 finale(self); 13769 return; 13770 } else if (typeof then === 'function') { 13771 doResolve(bind(then, newValue), self); 13772 return; 13773 } 13774 } 13775 self._state = 1; 13776 self._value = newValue; 13777 finale(self); 13778 } catch (e) { 13779 reject(self, e); 13780 } 13781 } 13782 function reject(self, newValue) { 13783 self._state = 2; 13784 self._value = newValue; 13785 finale(self); 13786 } 13787 function finale(self) { 13788 if (self._state === 2 && self._deferreds.length === 0) { 13789 Promise._immediateFn(function () { 13790 if (!self._handled) { 13791 Promise._unhandledRejectionFn(self._value); 13792 } 13793 }); 13794 } 13795 for (var i = 0, len = self._deferreds.length; i < len; i++) { 13796 handle(self, self._deferreds[i]); 13797 } 13798 self._deferreds = null; 13799 } 13800 function Handler(onFulfilled, onRejected, promise) { 13801 this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null; 13802 this.onRejected = typeof onRejected === 'function' ? onRejected : null; 13803 this.promise = promise; 13804 } 13805 function doResolve(fn, self) { 13806 var done = false;
13807 try { 13808 fn(function (value) { 13809 if (done) 13810 return; 13811 done = true; 13812 resolve(self, value); 13813 }, function (reason) { 13814 if (done) 13815 return; 13816 done = true; 13817 reject(self, reason); 13818 }); 13819 } catch (ex) { 13820 if (done) 13821 return; 13822 done = true; 13823 reject(self, ex); 13824 } 13825 } 13826 Promise.prototype['catch'] = function (onRejected) { 13827 return this.then(null, onRejected); 13828 }; 13829 Promise.prototype.then = function (onFulfilled, onRejected) { 13830 var prom = new this.constructor(noop); 13831 handle(this, new Handler(onFulfilled, onRejected, prom)); 13832 return prom; 13833 }; 13834 Promise.all = function (arr) { 13835 var args = Array.prototype.slice.call(arr); 13836 return new Promise(function (resolve, reject) { 13837 if (args.length === 0) 13838 return resolve([]); 13839 var remaining = args.length; 13840 function res(i, val) { 13841 try { 13842 if (val && (typeof val === 'object' || typeof val === 'function')) { 13843 var then = val.then; 13844 if (typeof then === 'function') { 13845 then.call(val, function (val) { 13846 res(i, val); 13847 }, reject); 13848 return; 13849 } 13850 } 13851 args[i] = val; 13852 if (--remaining === 0) { 13853 resolve(args); 13854 } 13855 } catch (ex) { 13856 reject(ex); 13857 } 13858 } 13859 for (var i = 0; i < args.length; i++) { 13860 res(i, args[i]); 13861 } 13862 }); 13863 }; 13864 Promise.resolve = function (value) { 13865 if (value && typeof value === 'object' && value.constructor === Promise) { 13866 return value; 13867 } 13868 return new Promise(function (resolve) { 13869 resolve(value); 13870 }); 13871 }; 13872 Promise.reject = function (value) { 13873 return new Promise(function (resolve, reject) { 13874 reject(value); 13875 }); 13876 }; 13877 Promise.race = function (values) { 13878 return new Promise(function (resolve, reject) { 13879 for (var i = 0, len = values.length; i < len; i++) { 13880 values[i].then(resolve, reject); 13881 } 13882 }); 13883 }; 13884 Promise._immediateFn = typeof setImmediate === 'function' ? function (fn) { 13885 setImmediate(fn); 13886 } : function (fn) { 13887 setTimeoutFunc(fn, 0); 13888 }; 13889 Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) { 13890 if (typeof console !== 'undefined' && console) { 13891 console.warn('Possible Unhandled Promise Rejection:', err); 13892 } 13893 }; 13894 Promise._setImmediateFn = function _setImmediateFn(fn) { 13895 Promise._immediateFn = fn; 13896 }; 13897 Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) { 13898 Promise._unhandledRejectionFn = fn; 13899 }; 13900 if (typeof module !== 'undefined' && module.exports) { 13901 module.exports = Promise; 13902 } else if (!root.Promise) { 13903 root.Promise = Promise; 13904 } 13905 }(this)); 13906 }.call(this, require('timers').setImmediate)); 13907 }, 13908 { 'timers': 3 } 13909 ], 13910 3: [
13911 function (require, module, exports) { 13912 (function (setImmediate, clearImmediate) { 13913 var nextTick = require('process/browser.js').nextTick; 13914 var apply = Function.prototype.apply; 13915 var slice = Array.prototype.slice; 13916 var immediateIds = {}; 13917 var nextImmediateId = 0; 13918 exports.setTimeout = function () { 13919 return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout); 13920 }; 13921 exports.setInterval = function () { 13922 return new Timeout(apply.call(setInterval, window, arguments), clearInterval); 13923 }; 13924 exports.clearTimeout = exports.clearInterval = function (timeout) { 13925 timeout.close(); 13926 }; 13927 function Timeout(id, clearFn) { 13928 this._id = id; 13929 this._clearFn = clearFn; 13930 } 13931 Timeout.prototype.unref = Timeout.prototype.ref = function () { 13932 }; 13933 Timeout.prototype.close = function () { 13934 this._clearFn.call(window, this._id); 13935 }; 13936 exports.enroll = function (item, msecs) { 13937 clearTimeout(item._idleTimeoutId); 13938 item._idleTimeout = msecs; 13939 }; 13940 exports.unenroll = function (item) { 13941 clearTimeout(item._idleTimeoutId); 13942 item._idleTimeout = -1; 13943 }; 13944 exports._unrefActive = exports.active = function (item) { 13945 clearTimeout(item._idleTimeoutId); 13946 var msecs = item._idleTimeout; 13947 if (msecs >= 0) { 13948 item._idleTimeoutId = setTimeout(function onTimeout() { 13949 if (item._onTimeout) 13950 item._onTimeout(); 13951 }, msecs); 13952 } 13953 }; 13954 exports.setImmediate = typeof setImmediate === 'function' ? setImmediate : function (fn) { 13955 var id = nextImmediateId++; 13956 var args = arguments.length < 2 ? false : slice.call(arguments, 1); 13957 immediateIds[id] = true; 13958 nextTick(function onNextTick() { 13959 if (immediateIds[id]) { 13960 if (args) { 13961 fn.apply(null, args); 13962 } else { 13963 fn.call(null); 13964 } 13965 exports.clearImmediate(id); 13966 } 13967 }); 13968 return id; 13969 }; 13970 exports.clearImmediate = typeof clearImmediate === 'function' ? clearImmediate : function (id) { 13971 delete immediateIds[id]; 13972 }; 13973 }.call(this, require('timers').setImmediate, require('timers').clearImmediate)); 13974 }, 13975 { 13976 'process/browser.js': 1, 13977 'timers': 3 13978 } 13979 ], 13980 4: [ 13981 function (require, module, exports) { 13982 var promisePolyfill = require('promise-polyfill'); 13983 var Global = function () { 13984 if (typeof window !== 'undefined') { 13985 return window; 13986 } else { 13987 return Function('return this;')(); 13988 } 13989 }(); 13990 module.exports = { boltExport: Global.Promise || promisePolyfill }; 13991 }, 13992 { 'promise-polyfill': 2 } 13993 ] 13994 }, {}, [4])(4); 13995 })); 13996 }(undefined, exports$1, module, undefined)); 13997 var Promise = module.exports.boltExport; 13998 13999 var nu$a = function (baseFn) { 14000 var data = Optional.none(); 14001 var callbacks = []; 14002 var map = function (f) { 14003 return nu$a(function (nCallback) { 14004 get(function (data) { 14005 nCallback(f(data)); 14006 }); 14007 }); 14008 }; 14009 var get = function (nCallback) { 14010 if (isReady()) { 14011 call(nCallback); 14012 } else { 14013 callbacks.push(nCallback); 14014 } 14015 }; 14016 var set = function (x) { 14017 if (!isReady()) { 14018 data = Optional.some(x); 14019 run(callbacks); 14020 callbacks = []; 14021 } 14022 }; 14023 var isReady = function () { 14024 return data.isSome(); 14025 }; 14026 var run = function (cbs) { 14027 each(cbs, call); 14028 }; 14029 var call = function (cb) { 14030 data.each(function (x) { 14031 setTimeout(function () { 14032 cb(x); 14033 }, 0); 14034 }); 14035 }; 14036 baseFn(set); 14037 return { 14038 get: get, 14039 map: map, 14040 isReady: isReady 14041 }; 14042 }; 14043 var pure = function (a) { 14044 return nu$a(function (callback) { 14045 callback(a); 14046 }); 14047 }; 14048 var LazyValue = { 14049 nu: nu$a, 14050 pure: pure 14051 }; 14052 14053 var errorReporter = function (err) { 14054 setTimeout(function () { 14055 throw err; 14056 }, 0); 14057 }; 14058 var make$3 = function (run) { 14059 var get = function (callback) { 14060 run().then(callback, errorReporter); 14061 }; 14062 var map = function (fab) { 14063 return make$3(function () { 14064 return run().then(fab); 14065 }); 14066 }; 14067 var bind = function (aFutureB) { 14068 return make$3(function () { 14069 return run().then(function (v) {
14070 return aFutureB(v).toPromise(); 14071 }); 14072 }); 14073 }; 14074 var anonBind = function (futureB) { 14075 return make$3(function () { 14076 return run().then(function () { 14077 return futureB.toPromise(); 14078 }); 14079 }); 14080 }; 14081 var toLazy = function () { 14082 return LazyValue.nu(get); 14083 }; 14084 var toCached = function () { 14085 var cache = null; 14086 return make$3(function () { 14087 if (cache === null) { 14088 cache = run(); 14089 } 14090 return cache; 14091 }); 14092 }; 14093 var toPromise = run; 14094 return { 14095 map: map, 14096 bind: bind, 14097 anonBind: anonBind, 14098 toLazy: toLazy, 14099 toCached: toCached, 14100 toPromise: toPromise, 14101 get: get 14102 }; 14103 }; 14104 var nu$b = function (baseFn) { 14105 return make$3(function () { 14106 return new Promise(baseFn); 14107 }); 14108 }; 14109 var pure$1 = function (a) { 14110 return make$3(function () { 14111 return Promise.resolve(a); 14112 }); 14113 }; 14114 var Future = { 14115 nu: nu$b, 14116 pure: pure$1 14117 }; 14118 14119 var ariaElements = [ 14120 'input', 14121 'textarea' 14122 ]; 14123 var isAriaElement = function (elem) { 14124 var name$1 = name(elem); 14125 return contains(ariaElements, name$1); 14126 }; 14127 var markValid = function (component, invalidConfig) { 14128 var elem = invalidConfig.getRoot(component).getOr(component.element); 14129 remove$4(elem, invalidConfig.invalidClass); 14130 invalidConfig.notify.each(function (notifyInfo) { 14131 if (isAriaElement(component.element)) { 14132 set$1(component.element, 'aria-invalid', false); 14133 } 14134 notifyInfo.getContainer(component).each(function (container) { 14135 set(container, notifyInfo.validHtml); 14136 }); 14137 notifyInfo.onValid(component); 14138 }); 14139 }; 14140 var markInvalid = function (component, invalidConfig, invalidState, text) { 14141 var elem = invalidConfig.getRoot(component).getOr(component.element); 14142 add$2(elem, invalidConfig.invalidClass); 14143 invalidConfig.notify.each(function (notifyInfo) { 14144 if (isAriaElement(component.element)) { 14145 set$1(component.element, 'aria-invalid', true); 14146 } 14147 notifyInfo.getContainer(component).each(function (container) { 14148 set(container, text); 14149 }); 14150 notifyInfo.onInvalid(component, text); 14151 }); 14152 }; 14153 var query = function (component, invalidConfig, _invalidState) { 14154 return invalidConfig.validator.fold(function () { 14155 return Future.pure(Result.value(true)); 14156 }, function (validatorInfo) { 14157 return validatorInfo.validate(component); 14158 }); 14159 }; 14160 var run$1 = function (component, invalidConfig, invalidState) { 14161 invalidConfig.notify.each(function (notifyInfo) { 14162 notifyInfo.onValidate(component); 14163 }); 14164 return query(component, invalidConfig).map(function (valid) { 14165 if (component.getSystem().isConnected()) { 14166 return valid.fold(function (err) { 14167 markInvalid(component, invalidConfig, invalidState, err); 14168 return Result.error(err); 14169 }, function (v) { 14170 markValid(component, invalidConfig); 14171 return Result.value(v); 14172 }); 14173 } else { 14174 return Result.error('No longer in system'); 14175 } 14176 }); 14177 }; 14178 var isInvalid = function (component, invalidConfig) { 14179 var elem = invalidConfig.getRoot(component).getOr(component.element); 14180 return has$2(elem, invalidConfig.invalidClass); 14181 }; 14182 14183 var InvalidateApis = /*#__PURE__*/Object.freeze({ 14184 __proto__: null, 14185 markValid: markValid, 14186 markInvalid: markInvalid, 14187 query: query, 14188 run: run$1, 14189 isInvalid: isInvalid 14190 }); 14191 14192 var events$a = function (invalidConfig, invalidState) { 14193 return invalidConfig.validator.map(function (validatorInfo) { 14194 return derive([run(validatorInfo.onEvent, function (component) { 14195 run$1(component, invalidConfig, invalidState).get(identity); 14196 })].concat(validatorInfo.validateOnLoad ? [runOnAttached(function (component) { 14197 run$1(component, invalidConfig, invalidState).get(noop); 14198 })] : [])); 14199 }).getOr({}); 14200 }; 14201 14202 var ActiveInvalidate = /*#__PURE__*/Object.freeze({ 14203 __proto__: null, 14204 events: events$a 14205 }); 14206 14207 var InvalidateSchema = [
14208 strict$1('invalidClass'), 14209 defaulted$1('getRoot', Optional.none), 14210 optionObjOf('notify', [ 14211 defaulted$1('aria', 'alert'), 14212 defaulted$1('getContainer', Optional.none), 14213 defaulted$1('validHtml', ''), 14214 onHandler('onValid'), 14215 onHandler('onInvalid'), 14216 onHandler('onValidate') 14217 ]), 14218 optionObjOf('validator', [ 14219 strict$1('validate'), 14220 defaulted$1('onEvent', 'input'), 14221 defaulted$1('validateOnLoad', true) 14222 ]) 14223 ]; 14224 14225 var Invalidating = create$1({ 14226 fields: InvalidateSchema, 14227 name: 'invalidating', 14228 active: ActiveInvalidate, 14229 apis: InvalidateApis, 14230 extra: { 14231 validation: function (validator) { 14232 return function (component) { 14233 var v = Representing.getValue(component); 14234 return Future.pure(validator(v)); 14235 }; 14236 } 14237 } 14238 }); 14239 14240 var getCoupled = function (component, coupleConfig, coupleState, name) { 14241 return coupleState.getOrCreate(component, coupleConfig, name); 14242 }; 14243 14244 var CouplingApis = /*#__PURE__*/Object.freeze({ 14245 __proto__: null, 14246 getCoupled: getCoupled 14247 }); 14248 14249 var CouplingSchema = [strictOf('others', setOf$1(Result.value, anyValue$1()))]; 14250 14251 var init$5 = function () { 14252 var coupled = {}; 14253 var getOrCreate = function (component, coupleConfig, name) { 14254 var available = keys(coupleConfig.others); 14255 if (!available) { 14256 throw new Error('Cannot find coupled component: ' + name + '. Known coupled components: ' + JSON.stringify(available, null, 2)); 14257 } else { 14258 return get$1(coupled, name).getOrThunk(function () { 14259 var builder = get$1(coupleConfig.others, name).getOrDie('No information found for coupled component: ' + name); 14260 var spec = builder(component); 14261 var built = component.getSystem().build(spec); 14262 coupled[name] = built; 14263 return built; 14264 }); 14265 } 14266 }; 14267 var readState = constant({}); 14268 return nu$5({ 14269 readState: readState, 14270 getOrCreate: getOrCreate 14271 }); 14272 }; 14273 14274 var CouplingState = /*#__PURE__*/Object.freeze({ 14275 __proto__: null, 14276 init: init$5 14277 }); 14278 14279 var Coupling = create$1({ 14280 fields: CouplingSchema, 14281 name: 'coupling', 14282 apis: CouplingApis, 14283 state: CouplingState 14284 }); 14285 14286 var suffix = constant('sink'); 14287 var partType = constant(optional({ 14288 name: suffix(), 14289 overrides: constant({ 14290 dom: { tag: 'div' }, 14291 behaviours: derive$1([Positioning.config({ useFixed: always })]), 14292 events: derive([ 14293 cutter(keydown()), 14294 cutter(mousedown()), 14295 cutter(click()) 14296 ]) 14297 }) 14298 })); 14299 14300 var HighlightOnOpen; 14301 (function (HighlightOnOpen) { 14302 HighlightOnOpen[HighlightOnOpen['HighlightFirst'] = 0] = 'HighlightFirst'; 14303 HighlightOnOpen[HighlightOnOpen['HighlightNone'] = 1] = 'HighlightNone'; 14304 }(HighlightOnOpen || (HighlightOnOpen = {}))); 14305 var getAnchor = function (detail, component) { 14306 var hotspot = detail.getHotspot(component).getOr(component); 14307 var anchor = 'hotspot'; 14308 var overrides = detail.getAnchorOverrides(); 14309 return detail.layouts.fold(function () { 14310 return { 14311 anchor: anchor, 14312 hotspot: hotspot, 14313 overrides: overrides 14314 }; 14315 }, function (layouts) { 14316 return { 14317 anchor: anchor, 14318 hotspot: hotspot, 14319 overrides: overrides, 14320 layouts: layouts 14321 }; 14322 }); 14323 }; 14324 var fetch = function (detail, mapFetch, component) { 14325 var fetcher = detail.fetch; 14326 return fetcher(component).map(mapFetch); 14327 }; 14328 var openF = function (detail, mapFetch, anchor, component, sandbox, externals, highlightOnOpen) { 14329 var futureData = fetch(detail, mapFetch, component); 14330 var getLazySink = getSink(component, detail); 14331 return futureData.map(function (tdata) { 14332 return tdata.bind(function (data) { 14333 return Optional.from(tieredMenu.sketch(__assign(__assign({}, externals.menu()), { 14334 uid: generate$2(''), 14335 data: data, 14336 highlightImmediately: highlightOnOpen === HighlightOnOpen.HighlightFirst, 14337 onOpenMenu: function (tmenu, menu) { 14338 var sink = getLazySink().getOrDie(); 14339 Positioning.position(sink, anchor, menu); 14340 Sandboxing.decloak(sandbox); 14341 }, 14342 onOpenSubmenu: function (tmenu, item, submenu) { 14343 var sink = getLazySink().getOrDie(); 14344 Positioning.position(sink, { 14345 anchor: 'submenu', 14346 item: item 14347 }, submenu); 14348 Sandboxing.decloak(sandbox); 14349 }, 14350 onRepositionMenu: function (tmenu, primaryMenu, submenuTriggers) { 14351 var sink = getLazySink().getOrDie(); 14352 Positioning.position(sink, anchor, primaryMenu); 14353 each(submenuTriggers, function (st) { 14354 Positioning.position(sink, { 14355 anchor: 'submenu', 14356 item: st.triggeringItem 14357 }, st.triggeredMenu); 14358 }); 14359 }, 14360 onEscape: function () { 14361 Focusing.focus(component); 14362 Sandboxing.close(sandbox); 14363 return Optional.some(true); 14364 } 14365 }))); 14366 }); 14367 }); 14368 }; 14369 var open$1 = function (detail, mapFetch, hotspot, sandbox, externals, onOpenSync, highlightOnOpen) { 14370 var anchor = getAnchor(detail, hotspot); 14371 var processed = openF(detail, mapFetch, anchor, hotspot, sandbox, externals, highlightOnOpen); 14372 return processed.map(function (tdata) { 14373 tdata.fold(function () { 14374 if (Sandboxing.isOpen(sandbox)) { 14375 Sandboxing.close(sandbox); 14376 } 14377 }, function (data) { 14378 Sandboxing.cloak(sandbox); 14379 Sandboxing.open(sandbox, data); 14380 onOpenSync(sandbox); 14381 }); 14382 return sandbox; 14383 }); 14384 }; 14385 var close$1 = function (detail, mapFetch, component, sandbox, _externals, _onOpenSync, _highlightOnOpen) { 14386 Sandboxing.close(sandbox); 14387 return Future.pure(sandbox); 14388 }; 14389 var togglePopup = function (detail, mapFetch, hotspot, externals, onOpenSync, highlightOnOpen) { 14390 var sandbox = Coupling.getCoupled(hotspot, 'sandbox'); 14391 var showing = Sandboxing.isOpen(sandbox); 14392 var action = showing ? close$1 : open$1; 14393 return action(detail, mapFetch, hotspot, sandbox, externals, onOpenSync, highlightOnOpen); 14394 }; 14395 var matchWidth = function (hotspot, container, useMinWidth) { 14396 var menu = Composing.getCurrent(container).getOr(container); 14397 var buttonWidth = get$8(hotspot.element); 14398 if (useMinWidth) { 14399 set$2(menu.element, 'min-width', buttonWidth + 'px'); 14400 } else { 14401 set$4(menu.element, buttonWidth); 14402 } 14403 }; 14404 var getSink = function (anyInSystem, sinkDetail) { 14405 return anyInSystem.getSystem().getByUid(sinkDetail.uid + '-' + suffix()).map(function (internalSink) { 14406 return function () { 14407 return Result.value(internalSink); 14408 }; 14409 }).getOrThunk(function () { 14410 return sinkDetail.lazySink.fold(function () { 14411 return function () { 14412 return Result.error(new Error('No internal sink is specified, nor could an external sink be found')); 14413 }; 14414 }, function (lazySinkFn) { 14415 return function () { 14416 return lazySinkFn(anyInSystem); 14417 }; 14418 }); 14419 }); 14420 }; 14421 var doRepositionMenus = function (sandbox) { 14422 Sandboxing.getState(sandbox).each(function (tmenu) { 14423 tieredMenu.repositionMenus(tmenu); 14424 }); 14425 }; 14426 var makeSandbox = function (detail, hotspot, extras) { 14427 var ariaOwner = manager(); 14428 var onOpen = function (component, menu) { 14429 var anchor = getAnchor(detail, hotspot); 14430 ariaOwner.link(hotspot.element); 14431 if (detail.matchWidth) { 14432 matchWidth(anchor.hotspot, menu, detail.useMinWidth); 14433 } 14434 detail.onOpen(anchor, component, menu); 14435 if (extras !== undefined && extras.onOpen !== undefined) { 14436 extras.onOpen(component, menu); 14437 } 14438 }; 14439 var onClose = function (component, menu) { 14440 ariaOwner.unlink(hotspot.element); 14441 if (extras !== undefined && extras.onClose !== undefined) { 14442 extras.onClose(component, menu); 14443 } 14444 }; 14445 var lazySink = getSink(hotspot, detail); 14446 return { 14447 dom: { 14448 tag: 'div', 14449 classes: detail.sandboxClasses, 14450 attributes: { 14451 id: ariaOwner.id, 14452 role: 'listbox' 14453 } 14454 }, 14455 behaviours: SketchBehaviours.augment(detail.sandboxBehaviours, [ 14456 Representing.config({ 14457 store: { 14458 mode: 'memory', 14459 initialValue: hotspot 14460 } 14461 }), 14462 Sandboxing.config({ 14463 onOpen: onOpen, 14464 onClose: onClose, 14465 isPartOf: function (container, data, queryElem) { 14466 return isPartOf(data, queryElem) || isPartOf(hotspot, queryElem); 14467 }, 14468 getAttachPoint: function () { 14469 return lazySink().getOrDie(); 14470 } 14471 }), 14472 Composing.config({ 14473 find: function (sandbox) { 14474 return Sandboxing.getState(sandbox).bind(function (menu) { 14475 return Composing.getCurrent(menu); 14476 }); 14477 } 14478 }), 14479 Receiving.config({ channels: __assign(__assign({}, receivingChannel({ isExtraPart: never })), receivingChannel$1({ doReposition: doRepositionMenus })) }) 14480 ]) 14481 }; 14482 }; 14483 var repositionMenus = function (comp) { 14484 var sandbox = Coupling.getCoupled(comp, 'sandbox'); 14485 doRepositionMenus(sandbox); 14486 }; 14487 14488 var sandboxFields = function () { 14489 return [ 14490 defaulted$1('sandboxClasses', []), 14491 SketchBehaviours.field('sandboxBehaviours', [ 14492 Composing, 14493 Receiving, 14494 Sandboxing, 14495 Representing 14496 ]) 14497 ]; 14498 }; 14499 14500 var schema$g = constant([
14501 strict$1('dom'), 14502 strict$1('fetch'), 14503 onHandler('onOpen'), 14504 onKeyboardHandler('onExecute'), 14505 defaulted$1('getHotspot', Optional.some), 14506 defaulted$1('getAnchorOverrides', constant({})), 14507 schema$1(), 14508 field$1('dropdownBehaviours', [ 14509 Toggling, 14510 Coupling, 14511 Keying, 14512 Focusing 14513 ]), 14514 strict$1('toggleClass'), 14515 defaulted$1('eventOrder', {}), 14516 option('lazySink'), 14517 defaulted$1('matchWidth', false), 14518 defaulted$1('useMinWidth', false), 14519 option('role') 14520 ].concat(sandboxFields())); 14521 var parts$4 = constant([ 14522 external$1({ 14523 schema: [tieredMenuMarkers()], 14524 name: 'menu', 14525 defaults: function (detail) { 14526 return { onExecute: detail.onExecute }; 14527 } 14528 }), 14529 partType() 14530 ]); 14531 14532 var factory$6 = function (detail, components, _spec, externals) { 14533 var _a; 14534 var lookupAttr = function (attr) { 14535 return get$1(detail.dom, 'attributes').bind(function (attrs) { 14536 return get$1(attrs, attr); 14537 }); 14538 }; 14539 var switchToMenu = function (sandbox) { 14540 Sandboxing.getState(sandbox).each(function (tmenu) { 14541 tieredMenu.highlightPrimary(tmenu); 14542 }); 14543 }; 14544 var action = function (component) { 14545 var onOpenSync = switchToMenu; 14546 togglePopup(detail, function (x) { 14547 return x; 14548 }, component, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop); 14549 }; 14550 var apis = { 14551 expand: function (comp) { 14552 if (!Toggling.isOn(comp)) { 14553 togglePopup(detail, function (x) { 14554 return x; 14555 }, comp, externals, noop, HighlightOnOpen.HighlightNone).get(noop); 14556 } 14557 }, 14558 open: function (comp) { 14559 if (!Toggling.isOn(comp)) { 14560 togglePopup(detail, function (x) { 14561 return x; 14562 }, comp, externals, noop, HighlightOnOpen.HighlightFirst).get(noop); 14563 } 14564 }, 14565 isOpen: Toggling.isOn, 14566 close: function (comp) { 14567 if (Toggling.isOn(comp)) { 14568 togglePopup(detail, function (x) { 14569 return x; 14570 }, comp, externals, noop, HighlightOnOpen.HighlightFirst).get(noop); 14571 } 14572 }, 14573 repositionMenus: function (comp) { 14574 if (Toggling.isOn(comp)) { 14575 repositionMenus(comp); 14576 } 14577 } 14578 }; 14579 var triggerExecute = function (comp, _se) { 14580 emitExecute(comp); 14581 return Optional.some(true); 14582 }; 14583 return { 14584 uid: detail.uid, 14585 dom: detail.dom, 14586 components: components, 14587 behaviours: augment(detail.dropdownBehaviours, [ 14588 Toggling.config({ 14589 toggleClass: detail.toggleClass, 14590 aria: { mode: 'expanded' } 14591 }), 14592 Coupling.config({ 14593 others: { 14594 sandbox: function (hotspot) { 14595 return makeSandbox(detail, hotspot, { 14596 onOpen: function () { 14597 return Toggling.on(hotspot); 14598 }, 14599 onClose: function () { 14600 return Toggling.off(hotspot); 14601 } 14602 }); 14603 } 14604 } 14605 }), 14606 Keying.config({ 14607 mode: 'special', 14608 onSpace: triggerExecute, 14609 onEnter: triggerExecute, 14610 onDown: function (comp, _se) { 14611 if (Dropdown.isOpen(comp)) { 14612 var sandbox = Coupling.getCoupled(comp, 'sandbox'); 14613 switchToMenu(sandbox); 14614 } else { 14615 Dropdown.open(comp); 14616 } 14617 return Optional.some(true); 14618 }, 14619 onEscape: function (comp, _se) { 14620 if (Dropdown.isOpen(comp)) { 14621 Dropdown.close(comp); 14622 return Optional.some(true); 14623 } else { 14624 return Optional.none(); 14625 } 14626 } 14627 }), 14628 Focusing.config({}) 14629 ]), 14630 events: events$7(Optional.some(action)), 14631 eventOrder: __assign(__assign({}, detail.eventOrder), (_a = {}, _a[execute()] = [ 14632 'disabling', 14633 'toggling', 14634 'alloy.base.behaviour' 14635 ], _a)), 14636 apis: apis, 14637 domModification: { 14638 attributes: __assign(__assign({ 'aria-haspopup': 'true' }, detail.role.fold(function () { 14639 return {}; 14640 }, function (role) { 14641 return { role: role }; 14642 })), detail.dom.tag === 'button' ? { type: lookupAttr('type').getOr('button') } : {}) 14643 } 14644 }; 14645 }; 14646 var Dropdown = composite$1({ 14647 name: 'Dropdown', 14648 configFields: schema$g(), 14649 partFields: parts$4(), 14650 factory: factory$6, 14651 apis: { 14652 open: function (apis, comp) { 14653 return apis.open(comp); 14654 }, 14655 expand: function (apis, comp) { 14656 return apis.expand(comp); 14657 }, 14658 close: function (apis, comp) { 14659 return apis.close(comp); 14660 }, 14661 isOpen: function (apis, comp) { 14662 return apis.isOpen(comp); 14663 }, 14664 repositionMenus: function (apis, comp) { 14665 return apis.repositionMenus(comp); 14666 } 14667 } 14668 }); 14669 14670 var exhibit$5 = function () { 14671 return nu$6({ 14672 styles: {
14673 '-webkit-user-select': 'none', 14674 'user-select': 'none', 14675 '-ms-user-select': 'none', 14676 '-moz-user-select': '-moz-none' 14677 }, 14678 attributes: { unselectable: 'on' } 14679 }); 14680 }; 14681 var events$b = function () { 14682 return derive([abort(selectstart(), always)]); 14683 }; 14684 14685 var ActiveUnselecting = /*#__PURE__*/Object.freeze({ 14686 __proto__: null, 14687 events: events$b, 14688 exhibit: exhibit$5 14689 }); 14690 14691 var Unselecting = create$1({ 14692 fields: [], 14693 name: 'unselecting', 14694 active: ActiveUnselecting 14695 }); 14696 14697 var renderPanelButton = function (spec, sharedBackstage) { 14698 return Dropdown.sketch({ 14699 dom: spec.dom, 14700 components: spec.components, 14701 toggleClass: 'mce-active', 14702 dropdownBehaviours: derive$1([ 14703 DisablingConfigs.button(sharedBackstage.providers.isDisabled), 14704 receivingConfig(), 14705 Unselecting.config({}), 14706 Tabstopping.config({}) 14707 ]), 14708 layouts: spec.layouts, 14709 sandboxClasses: ['tox-dialog__popups'], 14710 lazySink: sharedBackstage.getSink, 14711 fetch: function (comp) { 14712 return Future.nu(function (callback) { 14713 return spec.fetch(callback); 14714 }).map(function (items) { 14715 return Optional.from(createTieredDataFrom(deepMerge(createPartialChoiceMenu(generate$1('menu-value'), items, function (value) { 14716 spec.onItemAction(comp, value); 14717 }, spec.columns, spec.presets, ItemResponse$1.CLOSE_ON_EXECUTE, never, sharedBackstage.providers), { movement: deriveMenuMovement(spec.columns, spec.presets) }))); 14718 }); 14719 }, 14720 parts: { menu: part(false, 1, spec.presets) } 14721 }); 14722 }; 14723 14724 var colorInputChangeEvent = generate$1('color-input-change'); 14725 var colorSwatchChangeEvent = generate$1('color-swatch-change'); 14726 var colorPickerCancelEvent = generate$1('color-picker-cancel'); 14727 var renderColorInput = function (spec, sharedBackstage, colorInputBackstage) { 14728 var pField = FormField.parts.field({ 14729 factory: Input, 14730 inputClasses: ['tox-textfield'], 14731 onSetValue: function (c) { 14732 return Invalidating.run(c).get(noop); 14733 }, 14734 inputBehaviours: derive$1([ 14735 Disabling.config({ disabled: sharedBackstage.providers.isDisabled }), 14736 receivingConfig(), 14737 Tabstopping.config({}), 14738 Invalidating.config({ 14739 invalidClass: 'tox-textbox-field-invalid', 14740 getRoot: function (comp) { 14741 return parent(comp.element); 14742 }, 14743 notify: { 14744 onValid: function (comp) { 14745 var val = Representing.getValue(comp); 14746 emitWith(comp, colorInputChangeEvent, { color: val }); 14747 } 14748 }, 14749 validator: { 14750 validateOnLoad: false, 14751 validate: function (input) { 14752 var inputValue = Representing.getValue(input); 14753 if (inputValue.length === 0) { 14754 return Future.pure(Result.value(true)); 14755 } else { 14756 var span = SugarElement.fromTag('span'); 14757 set$2(span, 'background-color', inputValue); 14758 var res = getRaw(span, 'background-color').fold(function () { 14759 return Result.error('blah'); 14760 }, function (_) { 14761 return Result.value(inputValue); 14762 }); 14763 return Future.pure(res); 14764 } 14765 } 14766 } 14767 }) 14768 ]), 14769 selectOnFocus: false 14770 }); 14771 var pLabel = spec.label.map(function (label) { 14772 return renderLabel(label, sharedBackstage.providers); 14773 }); 14774 var emitSwatchChange = function (colorBit, value) { 14775 emitWith(colorBit, colorSwatchChangeEvent, { value: value }); 14776 }; 14777 var onItemAction = function (comp, value) { 14778 memColorButton.getOpt(comp).each(function (colorBit) { 14779 if (value === 'custom') { 14780 colorInputBackstage.colorPicker(function (valueOpt) { 14781 valueOpt.fold(function () { 14782 return emit(colorBit, colorPickerCancelEvent); 14783 }, function (value) { 14784 emitSwatchChange(colorBit, value);
14785 addColor(value); 14786 }); 14787 }, '#ffffff'); 14788 } else if (value === 'remove') { 14789 emitSwatchChange(colorBit, ''); 14790 } else { 14791 emitSwatchChange(colorBit, value); 14792 } 14793 }); 14794 }; 14795 var memColorButton = record(renderPanelButton({ 14796 dom: { 14797 tag: 'span', 14798 attributes: { 'aria-label': sharedBackstage.providers.translate('Color swatch') } 14799 }, 14800 layouts: { 14801 onRtl: function () { 14802 return [ 14803 southwest$1, 14804 southeast$1, 14805 south$1 14806 ]; 14807 }, 14808 onLtr: function () { 14809 return [ 14810 southeast$1, 14811 southwest$1, 14812 south$1 14813 ]; 14814 } 14815 }, 14816 components: [], 14817 fetch: getFetch(colorInputBackstage.getColors(), colorInputBackstage.hasCustomColors()), 14818 columns: colorInputBackstage.getColorCols(), 14819 presets: 'color', 14820 onItemAction: onItemAction 14821 }, sharedBackstage)); 14822 return FormField.sketch({ 14823 dom: { 14824 tag: 'div', 14825 classes: ['tox-form__group'] 14826 }, 14827 components: pLabel.toArray().concat([{ 14828 dom: { 14829 tag: 'div', 14830 classes: ['tox-color-input'] 14831 }, 14832 components: [ 14833 pField, 14834 memColorButton.asSpec() 14835 ] 14836 }]), 14837 fieldBehaviours: derive$1([config('form-field-events', [ 14838 run(colorInputChangeEvent, function (comp, se) { 14839 memColorButton.getOpt(comp).each(function (colorButton) { 14840 set$2(colorButton.element, 'background-color', se.event.color); 14841 }); 14842 emitWith(comp, formChangeEvent, { name: spec.name }); 14843 }), 14844 run(colorSwatchChangeEvent, function (comp, se) { 14845 FormField.getField(comp).each(function (field) { 14846 Representing.setValue(field, se.event.value); 14847 Composing.getCurrent(comp).each(Focusing.focus); 14848 }); 14849 }), 14850 run(colorPickerCancelEvent, function (comp, _se) { 14851 FormField.getField(comp).each(function (_field) { 14852 Composing.getCurrent(comp).each(Focusing.focus); 14853 }); 14854 }) 14855 ])]) 14856 }); 14857 }; 14858 14859 var labelPart = optional({ 14860 schema: [strict$1('dom')], 14861 name: 'label' 14862 }); 14863 var edgePart = function (name) { 14864 return optional({ 14865 name: '' + name + '-edge', 14866 overrides: function (detail) { 14867 var action = detail.model.manager.edgeActions[name]; 14868 return action.fold(function () { 14869 return {}; 14870 }, function (a) { 14871 return { 14872 events: derive([ 14873 runActionExtra(touchstart(), function (comp, se, d) { 14874 return a(comp, d); 14875 }, [detail]), 14876 runActionExtra(mousedown(), function (comp, se, d) { 14877 return a(comp, d); 14878 }, [detail]), 14879 runActionExtra(mousemove(), function (comp, se, det) { 14880 if (det.mouseIsDown.get()) { 14881 a(comp, det); 14882 } 14883 }, [detail]) 14884 ]) 14885 }; 14886 }); 14887 } 14888 }); 14889 }; 14890 var tlEdgePart = edgePart('top-left'); 14891 var tedgePart = edgePart('top'); 14892 var trEdgePart = edgePart('top-right'); 14893 var redgePart = edgePart('right'); 14894 var brEdgePart = edgePart('bottom-right'); 14895 var bedgePart = edgePart('bottom'); 14896 var blEdgePart = edgePart('bottom-left'); 14897 var ledgePart = edgePart('left'); 14898 var thumbPart = required({ 14899 name: 'thumb', 14900 defaults: constant({ dom: { styles: { position: 'absolute' } } }), 14901 overrides: function (detail) { 14902 return { 14903 events: derive([ 14904 redirectToPart(touchstart(), detail, 'spectrum'), 14905 redirectToPart(touchmove(), detail, 'spectrum'), 14906 redirectToPart(touchend(), detail, 'spectrum'), 14907 redirectToPart(mousedown(), detail, 'spectrum'), 14908 redirectToPart(mousemove(), detail, 'spectrum'), 14909 redirectToPart(mouseup(), detail, 'spectrum') 14910 ]) 14911 }; 14912 } 14913 }); 14914 var spectrumPart = required({ 14915 schema: [state$1('mouseIsDown', function () { 14916 return Cell(false); 14917 })], 14918 name: 'spectrum', 14919 overrides: function (detail) { 14920 var modelDetail = detail.model; 14921 var model = modelDetail.manager; 14922 var setValueFrom = function (component, simulatedEvent) { 14923 return model.getValueFromEvent(simulatedEvent).map(function (value) { 14924 return model.setValueFrom(component, detail, value); 14925 }); 14926 }; 14927 return { 14928 behaviours: derive$1([ 14929 Keying.config({
14930 mode: 'special', 14931 onLeft: function (spectrum) { 14932 return model.onLeft(spectrum, detail); 14933 }, 14934 onRight: function (spectrum) { 14935 return model.onRight(spectrum, detail); 14936 }, 14937 onUp: function (spectrum) { 14938 return model.onUp(spectrum, detail); 14939 }, 14940 onDown: function (spectrum) { 14941 return model.onDown(spectrum, detail); 14942 } 14943 }), 14944 Focusing.config({}) 14945 ]), 14946 events: derive([ 14947 run(touchstart(), setValueFrom), 14948 run(touchmove(), setValueFrom), 14949 run(mousedown(), setValueFrom), 14950 run(mousemove(), function (spectrum, se) { 14951 if (detail.mouseIsDown.get()) { 14952 setValueFrom(spectrum, se); 14953 } 14954 }) 14955 ]) 14956 }; 14957 } 14958 }); 14959 var SliderParts = [ 14960 labelPart, 14961 ledgePart, 14962 redgePart, 14963 tedgePart, 14964 bedgePart, 14965 tlEdgePart, 14966 trEdgePart, 14967 blEdgePart, 14968 brEdgePart, 14969 thumbPart, 14970 spectrumPart 14971 ]; 14972 14973 var _sliderChangeEvent = 'slider.change.value'; 14974 var sliderChangeEvent = constant(_sliderChangeEvent); 14975 var isTouchEvent = function (evt) { 14976 return evt.type.indexOf('touch') !== -1; 14977 }; 14978 var getEventSource = function (simulatedEvent) { 14979 var evt = simulatedEvent.event.raw; 14980 if (isTouchEvent(evt)) { 14981 var touchEvent = evt; 14982 return touchEvent.touches !== undefined && touchEvent.touches.length === 1 ? Optional.some(touchEvent.touches[0]).map(function (t) { 14983 return SugarPosition(t.clientX, t.clientY); 14984 }) : Optional.none(); 14985 } else { 14986 var mouseEvent = evt; 14987 return mouseEvent.clientX !== undefined ? Optional.some(mouseEvent).map(function (me) { 14988 return SugarPosition(me.clientX, me.clientY); 14989 }) : Optional.none(); 14990 } 14991 }; 14992 14993 var t = 'top', r$1 = 'right', b = 'bottom', l = 'left'; 14994 var minX = function (detail) { 14995 return detail.model.minX; 14996 }; 14997 var minY = function (detail) { 14998 return detail.model.minY; 14999 }; 15000 var min1X = function (detail) { 15001 return detail.model.minX - 1; 15002 }; 15003 var min1Y = function (detail) { 15004 return detail.model.minY - 1; 15005 }; 15006 var maxX = function (detail) { 15007 return detail.model.maxX; 15008 }; 15009 var maxY = function (detail) { 15010 return detail.model.maxY; 15011 }; 15012 var max1X = function (detail) { 15013 return detail.model.maxX + 1; 15014 }; 15015 var max1Y = function (detail) { 15016 return detail.model.maxY + 1; 15017 }; 15018 var range$2 = function (detail, max, min) { 15019 return max(detail) - min(detail); 15020 }; 15021 var xRange = function (detail) { 15022 return range$2(detail, maxX, minX); 15023 }; 15024 var yRange = function (detail) { 15025 return range$2(detail, maxY, minY); 15026 }; 15027 var halfX = function (detail) { 15028 return xRange(detail) / 2; 15029 }; 15030 var halfY = function (detail) { 15031 return yRange(detail) / 2; 15032 }; 15033 var step = function (detail) { 15034 return detail.stepSize; 15035 }; 15036 var snap = function (detail) { 15037 return detail.snapToGrid; 15038 }; 15039 var snapStart = function (detail) { 15040 return detail.snapStart; 15041 }; 15042 var rounded = function (detail) { 15043 return detail.rounded; 15044 }; 15045 var hasEdge = function (detail, edgeName) { 15046 return detail[edgeName + '-edge'] !== undefined; 15047 }; 15048 var hasLEdge = function (detail) { 15049 return hasEdge(detail, l); 15050 }; 15051 var hasREdge = function (detail) { 15052 return hasEdge(detail, r$1); 15053 }; 15054 var hasTEdge = function (detail) { 15055 return hasEdge(detail, t); 15056 }; 15057 var hasBEdge = function (detail) { 15058 return hasEdge(detail, b); 15059 }; 15060 var currentValue = function (detail) { 15061 return detail.model.value.get(); 15062 }; 15063 15064 var xValue = function (x) { 15065 return { x: x }; 15066 }; 15067 var yValue = function (y) { 15068 return { y: y }; 15069 }; 15070 var xyValue = function (x, y) { 15071 return { 15072 x: x, 15073 y: y 15074 }; 15075 }; 15076 var fireSliderChange = function (component, value) { 15077 emitWith(component, sliderChangeEvent(), { value: value }); 15078 }; 15079 var setToTLEdgeXY = function (edge, detail) { 15080 fireSliderChange(edge, xyValue(min1X(detail), min1Y(detail))); 15081 };
15082 var setToTEdge = function (edge, detail) { 15083 fireSliderChange(edge, yValue(min1Y(detail))); 15084 }; 15085 var setToTEdgeXY = function (edge, detail) { 15086 fireSliderChange(edge, xyValue(halfX(detail), min1Y(detail))); 15087 }; 15088 var setToTREdgeXY = function (edge, detail) { 15089 fireSliderChange(edge, xyValue(max1X(detail), min1Y(detail))); 15090 }; 15091 var setToREdge = function (edge, detail) { 15092 fireSliderChange(edge, xValue(max1X(detail))); 15093 }; 15094 var setToREdgeXY = function (edge, detail) { 15095 fireSliderChange(edge, xyValue(max1X(detail), halfY(detail))); 15096 }; 15097 var setToBREdgeXY = function (edge, detail) { 15098 fireSliderChange(edge, xyValue(max1X(detail), max1Y(detail))); 15099 }; 15100 var setToBEdge = function (edge, detail) { 15101 fireSliderChange(edge, yValue(max1Y(detail))); 15102 }; 15103 var setToBEdgeXY = function (edge, detail) { 15104 fireSliderChange(edge, xyValue(halfX(detail), max1Y(detail))); 15105 }; 15106 var setToBLEdgeXY = function (edge, detail) { 15107 fireSliderChange(edge, xyValue(min1X(detail), max1Y(detail))); 15108 }; 15109 var setToLEdge = function (edge, detail) { 15110 fireSliderChange(edge, xValue(min1X(detail))); 15111 }; 15112 var setToLEdgeXY = function (edge, detail) { 15113 fireSliderChange(edge, xyValue(min1X(detail), halfY(detail))); 15114 }; 15115 15116 var reduceBy = function (value, min, max, step) { 15117 if (value < min) { 15118 return value; 15119 } else if (value > max) { 15120 return max; 15121 } else if (value === min) { 15122 return min - 1; 15123 } else { 15124 return Math.max(min, value - step); 15125 } 15126 }; 15127 var increaseBy = function (value, min, max, step) { 15128 if (value > max) { 15129 return value; 15130 } else if (value < min) { 15131 return min; 15132 } else if (value === max) { 15133 return max + 1; 15134 } else { 15135 return Math.min(max, value + step); 15136 } 15137 }; 15138 var capValue = function (value, min, max) { 15139 return Math.max(min, Math.min(max, value)); 15140 }; 15141 var snapValueOf = function (value, min, max, step, snapStart) { 15142 return snapStart.fold(function () { 15143 var initValue = value - min; 15144 var extraValue = Math.round(initValue / step) * step; 15145 return capValue(min + extraValue, min - 1, max + 1); 15146 }, function (start) { 15147 var remainder = (value - start) % step; 15148 var adjustment = Math.round(remainder / step); 15149 var rawSteps = Math.floor((value - start) / step); 15150 var maxSteps = Math.floor((max - start) / step); 15151 var numSteps = Math.min(maxSteps, rawSteps + adjustment); 15152 var r = start + numSteps * step; 15153 return Math.max(start, r); 15154 }); 15155 }; 15156 var findOffsetOf = function (value, min, max) { 15157 return Math.min(max, Math.max(value, min)) - min; 15158 }; 15159 var findValueOf = function (args) { 15160 var min = args.min, max = args.max, range = args.range, value = args.value, step = args.step, snap = args.snap, snapStart = args.snapStart, rounded = args.rounded, hasMinEdge = args.hasMinEdge, hasMaxEdge = args.hasMaxEdge, minBound = args.minBound, maxBound = args.maxBound, screenRange = args.screenRange; 15161 var capMin = hasMinEdge ? min - 1 : min; 15162 var capMax = hasMaxEdge ? max + 1 : max; 15163 if (value < minBound) { 15164 return capMin; 15165 } else if (value > maxBound) { 15166 return capMax; 15167 } else { 15168 var offset = findOffsetOf(value, minBound, maxBound); 15169 var newValue = capValue(offset / screenRange * range + min, capMin, capMax); 15170 if (snap && newValue >= min && newValue <= max) { 15171 return snapValueOf(newValue, min, max, step, snapStart); 15172 } else if (rounded) { 15173 return Math.round(newValue); 15174 } else { 15175 return newValue; 15176 } 15177 } 15178 }; 15179 var findOffsetOfValue = function (args) { 15180 var min = args.min, max = args.max, range = args.range, value = args.value, hasMinEdge = args.hasMinEdge, hasMaxEdge = args.hasMaxEdge, maxBound = args.maxBound, maxOffset = args.maxOffset, centerMinEdge = args.centerMinEdge, centerMaxEdge = args.centerMaxEdge; 15181 if (value < min) { 15182 return hasMinEdge ? 0 : centerMinEdge; 15183 } else if (value > max) { 15184 return hasMaxEdge ? maxBound : centerMaxEdge; 15185 } else { 15186 return (value - min) / range * maxOffset; 15187 } 15188 }; 15189 15190 var top = 'top', right = 'right', bottom = 'bottom', left = 'left', width = 'width', height = 'height';
15191 var getBounds$1 = function (component) { 15192 return component.element.dom.getBoundingClientRect(); 15193 }; 15194 var getBoundsProperty = function (bounds, property) { 15195 return bounds[property]; 15196 }; 15197 var getMinXBounds = function (component) { 15198 var bounds = getBounds$1(component); 15199 return getBoundsProperty(bounds, left); 15200 }; 15201 var getMaxXBounds = function (component) { 15202 var bounds = getBounds$1(component); 15203 return getBoundsProperty(bounds, right); 15204 }; 15205 var getMinYBounds = function (component) { 15206 var bounds = getBounds$1(component); 15207 return getBoundsProperty(bounds, top); 15208 }; 15209 var getMaxYBounds = function (component) { 15210 var bounds = getBounds$1(component); 15211 return getBoundsProperty(bounds, bottom); 15212 }; 15213 var getXScreenRange = function (component) { 15214 var bounds = getBounds$1(component); 15215 return getBoundsProperty(bounds, width); 15216 }; 15217 var getYScreenRange = function (component) { 15218 var bounds = getBounds$1(component); 15219 return getBoundsProperty(bounds, height); 15220 }; 15221 var getCenterOffsetOf = function (componentMinEdge, componentMaxEdge, spectrumMinEdge) { 15222 return (componentMinEdge + componentMaxEdge) / 2 - spectrumMinEdge; 15223 }; 15224 var getXCenterOffSetOf = function (component, spectrum) { 15225 var componentBounds = getBounds$1(component); 15226 var spectrumBounds = getBounds$1(spectrum); 15227 var componentMinEdge = getBoundsProperty(componentBounds, left); 15228 var componentMaxEdge = getBoundsProperty(componentBounds, right); 15229 var spectrumMinEdge = getBoundsProperty(spectrumBounds, left); 15230 return getCenterOffsetOf(componentMinEdge, componentMaxEdge, spectrumMinEdge); 15231 }; 15232 var getYCenterOffSetOf = function (component, spectrum) { 15233 var componentBounds = getBounds$1(component); 15234 var spectrumBounds = getBounds$1(spectrum); 15235 var componentMinEdge = getBoundsProperty(componentBounds, top); 15236 var componentMaxEdge = getBoundsProperty(componentBounds, bottom); 15237 var spectrumMinEdge = getBoundsProperty(spectrumBounds, top); 15238 return getCenterOffsetOf(componentMinEdge, componentMaxEdge, spectrumMinEdge); 15239 }; 15240 15241 var fireSliderChange$1 = function (spectrum, value) { 15242 emitWith(spectrum, sliderChangeEvent(), { value: value }); 15243 }; 15244 var sliderValue = function (x) { 15245 return { x: x }; 15246 }; 15247 var findValueOfOffset = function (spectrum, detail, left) { 15248 var args = { 15249 min: minX(detail), 15250 max: maxX(detail), 15251 range: xRange(detail), 15252 value: left, 15253 step: step(detail), 15254 snap: snap(detail), 15255 snapStart: snapStart(detail), 15256 rounded: rounded(detail), 15257 hasMinEdge: hasLEdge(detail), 15258 hasMaxEdge: hasREdge(detail), 15259 minBound: getMinXBounds(spectrum), 15260 maxBound: getMaxXBounds(spectrum), 15261 screenRange: getXScreenRange(spectrum) 15262 }; 15263 return findValueOf(args); 15264 }; 15265 var setValueFrom = function (spectrum, detail, value) { 15266 var xValue = findValueOfOffset(spectrum, detail, value); 15267 var sliderVal = sliderValue(xValue); 15268 fireSliderChange$1(spectrum, sliderVal); 15269 return xValue; 15270 }; 15271 var setToMin = function (spectrum, detail) { 15272 var min = minX(detail); 15273 fireSliderChange$1(spectrum, sliderValue(min)); 15274 }; 15275 var setToMax = function (spectrum, detail) { 15276 var max = maxX(detail); 15277 fireSliderChange$1(spectrum, sliderValue(max)); 15278 }; 15279 var moveBy = function (direction, spectrum, detail) { 15280 var f = direction > 0 ? increaseBy : reduceBy; 15281 var xValue = f(currentValue(detail).x, minX(detail), maxX(detail), step(detail)); 15282 fireSliderChange$1(spectrum, sliderValue(xValue)); 15283 return Optional.some(xValue); 15284 }; 15285 var handleMovement = function (direction) { 15286 return function (spectrum, detail) { 15287 return moveBy(direction, spectrum, detail).map(always); 15288 }; 15289 }; 15290 var getValueFromEvent = function (simulatedEvent) { 15291 var pos = getEventSource(simulatedEvent); 15292 return pos.map(function (p) { 15293 return p.left; 15294 }); 15295 }; 15296 var findOffsetOfValue$1 = function (spectrum, detail, value, minEdge, maxEdge) { 15297 var minOffset = 0; 15298 var maxOffset = getXScreenRange(spectrum); 15299 var centerMinEdge = minEdge.bind(function (edge) { 15300 return Optional.some(getXCenterOffSetOf(edge, spectrum)); 15301 }).getOr(minOffset); 15302 var centerMaxEdge = maxEdge.bind(function (edge) { 15303 return Optional.some(getXCenterOffSetOf(edge, spectrum)); 15304 }).getOr(maxOffset); 15305 var args = { 15306 min: minX(detail), 15307 max: maxX(detail), 15308 range: xRange(detail), 15309 value: value, 15310 hasMinEdge: hasLEdge(detail), 15311 hasMaxEdge: hasREdge(detail), 15312 minBound: getMinXBounds(spectrum), 15313 minOffset: minOffset, 15314 maxBound: getMaxXBounds(spectrum), 15315 maxOffset: maxOffset, 15316 centerMinEdge: centerMinEdge, 15317 centerMaxEdge: centerMaxEdge 15318 }; 15319 return findOffsetOfValue(args); 15320 }; 15321 var findPositionOfValue = function (slider, spectrum, value, minEdge, maxEdge, detail) { 15322 var offset = findOffsetOfValue$1(spectrum, detail, value, minEdge, maxEdge); 15323 return getMinXBounds(spectrum) - getMinXBounds(slider) + offset; 15324 }; 15325 var setPositionFromValue = function (slider, thumb, detail, edges) { 15326 var value = currentValue(detail); 15327 var pos = findPositionOfValue(slider, edges.getSpectrum(slider), value.x, edges.getLeftEdge(slider), edges.getRightEdge(slider), detail); 15328 var thumbRadius = get$8(thumb.element) / 2; 15329 set$2(thumb.element, 'left', pos - thumbRadius + 'px'); 15330 }; 15331 var onLeft = handleMovement(-1); 15332 var onRight = handleMovement(1); 15333 var onUp = Optional.none; 15334 var onDown = Optional.none; 15335 var edgeActions = { 15336 'top-left': Optional.none(), 15337 'top': Optional.none(), 15338 'top-right': Optional.none(), 15339 'right': Optional.some(setToREdge),
15340 'bottom-right': Optional.none(), 15341 'bottom': Optional.none(), 15342 'bottom-left': Optional.none(), 15343 'left': Optional.some(setToLEdge) 15344 }; 15345 15346 var HorizontalModel = /*#__PURE__*/Object.freeze({ 15347 __proto__: null, 15348 setValueFrom: setValueFrom, 15349 setToMin: setToMin, 15350 setToMax: setToMax, 15351 findValueOfOffset: findValueOfOffset, 15352 getValueFromEvent: getValueFromEvent, 15353 findPositionOfValue: findPositionOfValue, 15354 setPositionFromValue: setPositionFromValue, 15355 onLeft: onLeft, 15356 onRight: onRight, 15357 onUp: onUp, 15358 onDown: onDown, 15359 edgeActions: edgeActions 15360 }); 15361 15362 var fireSliderChange$2 = function (spectrum, value) { 15363 emitWith(spectrum, sliderChangeEvent(), { value: value }); 15364 }; 15365 var sliderValue$1 = function (y) { 15366 return { y: y }; 15367 }; 15368 var findValueOfOffset$1 = function (spectrum, detail, top) { 15369 var args = { 15370 min: minY(detail), 15371 max: maxY(detail), 15372 range: yRange(detail), 15373 value: top, 15374 step: step(detail), 15375 snap: snap(detail), 15376 snapStart: snapStart(detail), 15377 rounded: rounded(detail), 15378 hasMinEdge: hasTEdge(detail), 15379 hasMaxEdge: hasBEdge(detail), 15380 minBound: getMinYBounds(spectrum), 15381 maxBound: getMaxYBounds(spectrum), 15382 screenRange: getYScreenRange(spectrum) 15383 }; 15384 return findValueOf(args); 15385 }; 15386 var setValueFrom$1 = function (spectrum, detail, value) { 15387 var yValue = findValueOfOffset$1(spectrum, detail, value); 15388 var sliderVal = sliderValue$1(yValue); 15389 fireSliderChange$2(spectrum, sliderVal); 15390 return yValue; 15391 }; 15392 var setToMin$1 = function (spectrum, detail) { 15393 var min = minY(detail); 15394 fireSliderChange$2(spectrum, sliderValue$1(min)); 15395 }; 15396 var setToMax$1 = function (spectrum, detail) { 15397 var max = maxY(detail); 15398 fireSliderChange$2(spectrum, sliderValue$1(max)); 15399 }; 15400 var moveBy$1 = function (direction, spectrum, detail) { 15401 var f = direction > 0 ? increaseBy : reduceBy; 15402 var yValue = f(currentValue(detail).y, minY(detail), maxY(detail), step(detail)); 15403 fireSliderChange$2(spectrum, sliderValue$1(yValue)); 15404 return Optional.some(yValue); 15405 }; 15406 var handleMovement$1 = function (direction) { 15407 return function (spectrum, detail) { 15408 return moveBy$1(direction, spectrum, detail).map(always); 15409 }; 15410 }; 15411 var getValueFromEvent$1 = function (simulatedEvent) { 15412 var pos = getEventSource(simulatedEvent); 15413 return pos.map(function (p) { 15414 return p.top; 15415 }); 15416 }; 15417 var findOffsetOfValue$2 = function (spectrum, detail, value, minEdge, maxEdge) { 15418 var minOffset = 0; 15419 var maxOffset = getYScreenRange(spectrum); 15420 var centerMinEdge = minEdge.bind(function (edge) { 15421 return Optional.some(getYCenterOffSetOf(edge, spectrum)); 15422 }).getOr(minOffset); 15423 var centerMaxEdge = maxEdge.bind(function (edge) { 15424 return Optional.some(getYCenterOffSetOf(edge, spectrum)); 15425 }).getOr(maxOffset); 15426 var args = { 15427 min: minY(detail), 15428 max: maxY(detail), 15429 range: yRange(detail), 15430 value: value, 15431 hasMinEdge: hasTEdge(detail), 15432 hasMaxEdge: hasBEdge(detail), 15433 minBound: getMinYBounds(spectrum), 15434 minOffset: minOffset, 15435 maxBound: getMaxYBounds(spectrum), 15436 maxOffset: maxOffset, 15437 centerMinEdge: centerMinEdge, 15438 centerMaxEdge: centerMaxEdge 15439 }; 15440 return findOffsetOfValue(args); 15441 }; 15442 var findPositionOfValue$1 = function (slider, spectrum, value, minEdge, maxEdge, detail) { 15443 var offset = findOffsetOfValue$2(spectrum, detail, value, minEdge, maxEdge); 15444 return getMinYBounds(spectrum) - getMinYBounds(slider) + offset; 15445 }; 15446 var setPositionFromValue$1 = function (slider, thumb, detail, edges) { 15447 var value = currentValue(detail); 15448 var pos = findPositionOfValue$1(slider, edges.getSpectrum(slider), value.y, edges.getTopEdge(slider), edges.getBottomEdge(slider), detail); 15449 var thumbRadius = get$7(thumb.element) / 2; 15450 set$2(thumb.element, 'top', pos - thumbRadius + 'px'); 15451 }; 15452 var onLeft$1 = Optional.none; 15453 var onRight$1 = Optional.none; 15454 var onUp$1 = handleMovement$1(-1); 15455 var onDown$1 = handleMovement$1(1); 15456 var edgeActions$1 = { 15457 'top-left': Optional.none(), 15458 'top': Optional.some(setToTEdge), 15459 'top-right': Optional.none(), 15460 'right': Optional.none(), 15461 'bottom-right': Optional.none(), 15462 'bottom': Optional.some(setToBEdge),
15463 'bottom-left': Optional.none(), 15464 'left': Optional.none() 15465 }; 15466 15467 var VerticalModel = /*#__PURE__*/Object.freeze({ 15468 __proto__: null, 15469 setValueFrom: setValueFrom$1, 15470 setToMin: setToMin$1, 15471 setToMax: setToMax$1, 15472 findValueOfOffset: findValueOfOffset$1, 15473 getValueFromEvent: getValueFromEvent$1, 15474 findPositionOfValue: findPositionOfValue$1, 15475 setPositionFromValue: setPositionFromValue$1, 15476 onLeft: onLeft$1, 15477 onRight: onRight$1, 15478 onUp: onUp$1, 15479 onDown: onDown$1, 15480 edgeActions: edgeActions$1 15481 }); 15482 15483 var fireSliderChange$3 = function (spectrum, value) { 15484 emitWith(spectrum, sliderChangeEvent(), { value: value }); 15485 }; 15486 var sliderValue$2 = function (x, y) { 15487 return { 15488 x: x, 15489 y: y 15490 }; 15491 }; 15492 var setValueFrom$2 = function (spectrum, detail, value) { 15493 var xValue = findValueOfOffset(spectrum, detail, value.left); 15494 var yValue = findValueOfOffset$1(spectrum, detail, value.top); 15495 var val = sliderValue$2(xValue, yValue); 15496 fireSliderChange$3(spectrum, val); 15497 return val; 15498 }; 15499 var moveBy$2 = function (direction, isVerticalMovement, spectrum, detail) { 15500 var f = direction > 0 ? increaseBy : reduceBy; 15501 var xValue = isVerticalMovement ? currentValue(detail).x : f(currentValue(detail).x, minX(detail), maxX(detail), step(detail)); 15502 var yValue = !isVerticalMovement ? currentValue(detail).y : f(currentValue(detail).y, minY(detail), maxY(detail), step(detail)); 15503 fireSliderChange$3(spectrum, sliderValue$2(xValue, yValue)); 15504 return Optional.some(xValue); 15505 }; 15506 var handleMovement$2 = function (direction, isVerticalMovement) { 15507 return function (spectrum, detail) { 15508 return moveBy$2(direction, isVerticalMovement, spectrum, detail).map(always); 15509 }; 15510 }; 15511 var setToMin$2 = function (spectrum, detail) { 15512 var mX = minX(detail); 15513 var mY = minY(detail); 15514 fireSliderChange$3(spectrum, sliderValue$2(mX, mY)); 15515 }; 15516 var setToMax$2 = function (spectrum, detail) { 15517 var mX = maxX(detail); 15518 var mY = maxY(detail); 15519 fireSliderChange$3(spectrum, sliderValue$2(mX, mY)); 15520 }; 15521 var getValueFromEvent$2 = function (simulatedEvent) { 15522 return getEventSource(simulatedEvent); 15523 }; 15524 var setPositionFromValue$2 = function (slider, thumb, detail, edges) { 15525 var value = currentValue(detail); 15526 var xPos = findPositionOfValue(slider, edges.getSpectrum(slider), value.x, edges.getLeftEdge(slider), edges.getRightEdge(slider), detail); 15527 var yPos = findPositionOfValue$1(slider, edges.getSpectrum(slider), value.y, edges.getTopEdge(slider), edges.getBottomEdge(slider), detail); 15528 var thumbXRadius = get$8(thumb.element) / 2; 15529 var thumbYRadius = get$7(thumb.element) / 2; 15530 set$2(thumb.element, 'left', xPos - thumbXRadius + 'px'); 15531 set$2(thumb.element, 'top', yPos - thumbYRadius + 'px'); 15532 }; 15533 var onLeft$2 = handleMovement$2(-1, false); 15534 var onRight$2 = handleMovement$2(1, false); 15535 var onUp$2 = handleMovement$2(-1, true); 15536 var onDown$2 = handleMovement$2(1, true); 15537 var edgeActions$2 = { 15538 'top-left': Optional.some(setToTLEdgeXY), 15539 'top': Optional.some(setToTEdgeXY), 15540 'top-right': Optional.some(setToTREdgeXY), 15541 'right': Optional.some(setToREdgeXY), 15542 'bottom-right': Optional.some(setToBREdgeXY), 15543 'bottom': Optional.some(setToBEdgeXY), 15544 'bottom-left': Optional.some(setToBLEdgeXY), 15545 'left': Optional.some(setToLEdgeXY) 15546 }; 15547 15548 var TwoDModel = /*#__PURE__*/Object.freeze({ 15549 __proto__: null, 15550 setValueFrom: setValueFrom$2, 15551 setToMin: setToMin$2, 15552 setToMax: setToMax$2, 15553 getValueFromEvent: getValueFromEvent$2, 15554 setPositionFromValue: setPositionFromValue$2, 15555 onLeft: onLeft$2, 15556 onRight: onRight$2, 15557 onUp: onUp$2, 15558 onDown: onDown$2, 15559 edgeActions: edgeActions$2 15560 }); 15561 15562 var SliderSchema = [ 15563 defaulted$1('stepSize', 1), 15564 defaulted$1('onChange', noop), 15565 defaulted$1('onChoose', noop), 15566 defaulted$1('onInit', noop),
15567 defaulted$1('onDragStart', noop), 15568 defaulted$1('onDragEnd', noop), 15569 defaulted$1('snapToGrid', false), 15570 defaulted$1('rounded', true), 15571 option('snapStart'), 15572 strictOf('model', choose$1('mode', { 15573 x: [ 15574 defaulted$1('minX', 0), 15575 defaulted$1('maxX', 100), 15576 state$1('value', function (spec) { 15577 return Cell(spec.mode.minX); 15578 }), 15579 strict$1('getInitialValue'), 15580 output('manager', HorizontalModel) 15581 ], 15582 y: [ 15583 defaulted$1('minY', 0), 15584 defaulted$1('maxY', 100), 15585 state$1('value', function (spec) { 15586 return Cell(spec.mode.minY); 15587 }), 15588 strict$1('getInitialValue'), 15589 output('manager', VerticalModel) 15590 ], 15591 xy: [ 15592 defaulted$1('minX', 0), 15593 defaulted$1('maxX', 100), 15594 defaulted$1('minY', 0), 15595 defaulted$1('maxY', 100), 15596 state$1('value', function (spec) { 15597 return Cell({ 15598 x: spec.mode.minX, 15599 y: spec.mode.minY 15600 }); 15601 }), 15602 strict$1('getInitialValue'), 15603 output('manager', TwoDModel) 15604 ] 15605 })), 15606 field$1('sliderBehaviours', [ 15607 Keying, 15608 Representing 15609 ]), 15610 state$1('mouseIsDown', function () { 15611 return Cell(false); 15612 }) 15613 ]; 15614 15615 var sketch = function (detail, components, _spec, _externals) { 15616 var _a; 15617 var getThumb = function (component) { 15618 return getPartOrDie(component, detail, 'thumb'); 15619 }; 15620 var getSpectrum = function (component) { 15621 return getPartOrDie(component, detail, 'spectrum'); 15622 }; 15623 var getLeftEdge = function (component) { 15624 return getPart(component, detail, 'left-edge'); 15625 }; 15626 var getRightEdge = function (component) { 15627 return getPart(component, detail, 'right-edge'); 15628 }; 15629 var getTopEdge = function (component) { 15630 return getPart(component, detail, 'top-edge'); 15631 }; 15632 var getBottomEdge = function (component) { 15633 return getPart(component, detail, 'bottom-edge'); 15634 }; 15635 var modelDetail = detail.model; 15636 var model = modelDetail.manager; 15637 var refresh = function (slider, thumb) { 15638 model.setPositionFromValue(slider, thumb, detail, { 15639 getLeftEdge: getLeftEdge, 15640 getRightEdge: getRightEdge, 15641 getTopEdge: getTopEdge, 15642 getBottomEdge: getBottomEdge, 15643 getSpectrum: getSpectrum 15644 }); 15645 }; 15646 var setValue = function (slider, newValue) { 15647 modelDetail.value.set(newValue); 15648 var thumb = getThumb(slider); 15649 refresh(slider, thumb); 15650 }; 15651 var changeValue = function (slider, newValue) { 15652 setValue(slider, newValue); 15653 var thumb = getThumb(slider); 15654 detail.onChange(slider, thumb, newValue); 15655 return Optional.some(true); 15656 }; 15657 var resetToMin = function (slider) { 15658 model.setToMin(slider, detail); 15659 }; 15660 var resetToMax = function (slider) { 15661 model.setToMax(slider, detail); 15662 }; 15663 var choose = function (slider) { 15664 var fireOnChoose = function () { 15665 getPart(slider, detail, 'thumb').each(function (thumb) { 15666 var value = modelDetail.value.get(); 15667 detail.onChoose(slider, thumb, value); 15668 }); 15669 }; 15670 var wasDown = detail.mouseIsDown.get(); 15671 detail.mouseIsDown.set(false); 15672 if (wasDown) { 15673 fireOnChoose(); 15674 } 15675 }; 15676 var onDragStart = function (slider, simulatedEvent) { 15677 simulatedEvent.stop(); 15678 detail.mouseIsDown.set(true); 15679 detail.onDragStart(slider, getThumb(slider)); 15680 }; 15681 var onDragEnd = function (slider, simulatedEvent) { 15682 simulatedEvent.stop(); 15683 detail.onDragEnd(slider, getThumb(slider)); 15684 choose(slider); 15685 }; 15686 return { 15687 uid: detail.uid, 15688 dom: detail.dom, 15689 components: components, 15690 behaviours: augment(detail.sliderBehaviours, [ 15691 Keying.config({ 15692 mode: 'special', 15693 focusIn: function (slider) { 15694 return getPart(slider, detail, 'spectrum').map(Keying.focusIn).map(always); 15695 } 15696 }), 15697 Representing.config({ 15698 store: { 15699 mode: 'manual', 15700 getValue: function (_) { 15701 return modelDetail.value.get(); 15702 } 15703 } 15704 }), 15705 Receiving.config({ channels: (_a = {}, _a[mouseReleased()] = { onReceive: choose }, _a) }) 15706 ]), 15707 events: derive([ 15708 run(sliderChangeEvent(), function (slider, simulatedEvent) { 15709 changeValue(slider, simulatedEvent.event.value); 15710 }), 15711 runOnAttached(function (slider, _simulatedEvent) { 15712 var getInitial = modelDetail.getInitialValue(); 15713 modelDetail.value.set(getInitial);
15714 var thumb = getThumb(slider); 15715 refresh(slider, thumb); 15716 var spectrum = getSpectrum(slider); 15717 detail.onInit(slider, thumb, spectrum, modelDetail.value.get()); 15718 }), 15719 run(touchstart(), onDragStart), 15720 run(touchend(), onDragEnd), 15721 run(mousedown(), onDragStart), 15722 run(mouseup(), onDragEnd) 15723 ]), 15724 apis: { 15725 resetToMin: resetToMin, 15726 resetToMax: resetToMax, 15727 setValue: setValue, 15728 refresh: refresh 15729 }, 15730 domModification: { styles: { position: 'relative' } } 15731 }; 15732 }; 15733 15734 var Slider = composite$1({ 15735 name: 'Slider', 15736 configFields: SliderSchema, 15737 partFields: SliderParts, 15738 factory: sketch, 15739 apis: { 15740 setValue: function (apis, slider, value) { 15741 apis.setValue(slider, value); 15742 }, 15743 resetToMin: function (apis, slider) { 15744 apis.resetToMin(slider); 15745 }, 15746 resetToMax: function (apis, slider) { 15747 apis.resetToMax(slider); 15748 }, 15749 refresh: function (apis, slider) { 15750 apis.refresh(slider); 15751 } 15752 } 15753 }); 15754 15755 var hsvColour = function (hue, saturation, value) { 15756 return { 15757 hue: hue, 15758 saturation: saturation, 15759 value: value 15760 }; 15761 }; 15762 var fromRgb = function (rgbaColour) { 15763 var h = 0; 15764 var s = 0; 15765 var v = 0; 15766 var r = rgbaColour.red / 255; 15767 var g = rgbaColour.green / 255; 15768 var b = rgbaColour.blue / 255; 15769 var minRGB = Math.min(r, Math.min(g, b)); 15770 var maxRGB = Math.max(r, Math.max(g, b)); 15771 if (minRGB === maxRGB) { 15772 v = minRGB; 15773 return hsvColour(0, 0, v * 100); 15774 } 15775 var d = r === minRGB ? g - b : b === minRGB ? r - g : b - r; 15776 h = r === minRGB ? 3 : b === minRGB ? 1 : 5; 15777 h = 60 * (h - d / (maxRGB - minRGB)); 15778 s = (maxRGB - minRGB) / maxRGB; 15779 v = maxRGB; 15780 return hsvColour(Math.round(h), Math.round(s * 100), Math.round(v * 100)); 15781 }; 15782 15783 var hexToHsv = function (hex) { 15784 return fromRgb(fromHex(hex)); 15785 }; 15786 var hsvToHex = function (hsv) { 15787 return fromRgba(fromHsv(hsv)); 15788 }; 15789 15790 var fieldsUpdate = generate$1('rgb-hex-update'); 15791 var sliderUpdate = generate$1('slider-update'); 15792 var paletteUpdate = generate$1('palette-update'); 15793 15794 var sliderFactory = function (translate, getClass) { 15795 var spectrum = Slider.parts.spectrum({ 15796 dom: { 15797 tag: 'div', 15798 classes: [getClass('hue-slider-spectrum')], 15799 attributes: { role: 'presentation' } 15800 } 15801 }); 15802 var thumb = Slider.parts.thumb({ 15803 dom: { 15804 tag: 'div', 15805 classes: [getClass('hue-slider-thumb')], 15806 attributes: { role: 'presentation' } 15807 } 15808 }); 15809 return Slider.sketch({ 15810 dom: { 15811 tag: 'div', 15812 classes: [getClass('hue-slider')], 15813 attributes: { role: 'presentation' } 15814 }, 15815 rounded: false, 15816 model: { 15817 mode: 'y', 15818 getInitialValue: constant({ y: 0 }) 15819 }, 15820 components: [ 15821 spectrum, 15822 thumb 15823 ], 15824 sliderBehaviours: derive$1([Focusing.config({})]), 15825 onChange: function (slider, _thumb, value) { 15826 emitWith(slider, sliderUpdate, { value: value }); 15827 } 15828 }); 15829 }; 15830 15831 var owner$3 = 'form'; 15832 var schema$h = [field$1('formBehaviours', [Representing])]; 15833 var getPartName = function (name) { 15834 return '<alloy.field.' + name + '>'; 15835 }; 15836 var sketch$1 = function (fSpec) { 15837 var parts = function () { 15838 var record = []; 15839 var field = function (name, config) { 15840 record.push(name); 15841 return generateOne(owner$3, getPartName(name), config); 15842 }; 15843 return { 15844 field: field, 15845 record: function () { 15846 return record; 15847 } 15848 }; 15849 }(); 15850 var spec = fSpec(parts); 15851 var partNames = parts.record(); 15852 var fieldParts = map(partNames, function (n) { 15853 return required({ 15854 name: n, 15855 pname: getPartName(n) 15856 }); 15857 }); 15858 return composite(owner$3, schema$h, fieldParts, make$4, spec); 15859 }; 15860 var toResult$1 = function (o, e) { 15861 return o.fold(function () { 15862 return Result.error(e); 15863 }, Result.value); 15864 }; 15865 var make$4 = function (detail, components) { 15866 return { 15867 uid: detail.uid, 15868 dom: detail.dom, 15869 components: components, 15870 behaviours: augment(detail.formBehaviours, [Representing.config({ 15871 store: { 15872 mode: 'manual', 15873 getValue: function (form) { 15874 var resPs = getAllParts(form, detail); 15875 return map$2(resPs, function (resPThunk, pName) { 15876 return resPThunk().bind(function (v) { 15877 var opt = Composing.getCurrent(v); 15878 return toResult$1(opt, new Error('Cannot find a current component to extract the value from for form part \'' + pName + '\': ' + element(v.element))); 15879 }).map(Representing.getValue); 15880 }); 15881 }, 15882 setValue: function (form, values) { 15883 each$1(values, function (newValue, key) { 15884 getPart(form, detail, key).each(function (wrapper) { 15885 Composing.getCurrent(wrapper).each(function (field) { 15886 Representing.setValue(field, newValue); 15887 }); 15888 }); 15889 }); 15890 } 15891 } 15892 })]), 15893 apis: { 15894 getField: function (form, key) { 15895 return getPart(form, detail, key).bind(Composing.getCurrent); 15896 } 15897 } 15898 }; 15899 }; 15900 var Form = { 15901 getField: makeApi(function (apis, component, key) { 15902 return apis.getField(component, key); 15903 }), 15904 sketch: sketch$1 15905 }; 15906
15907 var validInput = generate$1('valid-input'); 15908 var invalidInput = generate$1('invalid-input'); 15909 var validatingInput = generate$1('validating-input'); 15910 var translatePrefix = 'colorcustom.rgb.'; 15911 var rgbFormFactory = function (translate, getClass, onValidHexx, onInvalidHexx) { 15912 var invalidation = function (label, isValid) { 15913 return Invalidating.config({ 15914 invalidClass: getClass('invalid'), 15915 notify: { 15916 onValidate: function (comp) { 15917 emitWith(comp, validatingInput, { type: label }); 15918 }, 15919 onValid: function (comp) { 15920 emitWith(comp, validInput, { 15921 type: label, 15922 value: Representing.getValue(comp) 15923 }); 15924 }, 15925 onInvalid: function (comp) { 15926 emitWith(comp, invalidInput, { 15927 type: label, 15928 value: Representing.getValue(comp) 15929 }); 15930 } 15931 }, 15932 validator: { 15933 validate: function (comp) { 15934 var value = Representing.getValue(comp); 15935 var res = isValid(value) ? Result.value(true) : Result.error(translate('aria.input.invalid')); 15936 return Future.pure(res); 15937 }, 15938 validateOnLoad: false 15939 } 15940 }); 15941 }; 15942 var renderTextField = function (isValid, name, label, description, data) { 15943 var helptext = translate(translatePrefix + 'range'); 15944 var pLabel = FormField.parts.label({ 15945 dom: { 15946 tag: 'label', 15947 innerHtml: label, 15948 attributes: { 'aria-label': description } 15949 } 15950 }); 15951 var pField = FormField.parts.field({ 15952 data: data, 15953 factory: Input, 15954 inputAttributes: __assign({ type: 'text' }, name === 'hex' ? { 'aria-live': 'polite' } : {}), 15955 inputClasses: [getClass('textfield')], 15956 inputBehaviours: derive$1([ 15957 invalidation(name, isValid), 15958 Tabstopping.config({}) 15959 ]), 15960 onSetValue: function (input) { 15961 if (Invalidating.isInvalid(input)) { 15962 var run = Invalidating.run(input); 15963 run.get(noop); 15964 } 15965 } 15966 }); 15967 var comps = [ 15968 pLabel, 15969 pField 15970 ]; 15971 var concats = name !== 'hex' ? [FormField.parts['aria-descriptor']({ text: helptext })] : []; 15972 var components = comps.concat(concats); 15973 return { 15974 dom: { 15975 tag: 'div', 15976 attributes: { role: 'presentation' } 15977 }, 15978 components: components 15979 }; 15980 }; 15981 var copyRgbToHex = function (form, rgba) { 15982 var hex = fromRgba(rgba); 15983 Form.getField(form, 'hex').each(function (hexField) { 15984 if (!Focusing.isFocused(hexField)) { 15985 Representing.setValue(form, { hex: hex.value }); 15986 } 15987 }); 15988 return hex; 15989 }; 15990 var copyRgbToForm = function (form, rgb) { 15991 var red = rgb.red; 15992 var green = rgb.green; 15993 var blue = rgb.blue; 15994 Representing.setValue(form, { 15995 red: red, 15996 green: green, 15997 blue: blue 15998 }); 15999 }; 16000 var memPreview = record({ 16001 dom: { 16002 tag: 'div', 16003 classes: [getClass('rgba-preview')], 16004 styles: { 'background-color': 'white' }, 16005 attributes: { role: 'presentation' } 16006 } 16007 }); 16008 var updatePreview = function (anyInSystem, hex) { 16009 memPreview.getOpt(anyInSystem).each(function (preview) { 16010 set$2(preview.element, 'background-color', '#' + hex.value); 16011 }); 16012 }; 16013 var factory = function () { 16014 var state = { 16015 red: Cell(Optional.some(255)), 16016 green: Cell(Optional.some(255)), 16017 blue: Cell(Optional.some(255)), 16018 hex: Cell(Optional.some('ffffff')) 16019 }; 16020 var copyHexToRgb = function (form, hex) { 16021 var rgb = fromHex(hex); 16022 copyRgbToForm(form, rgb); 16023 setValueRgb(rgb); 16024 }; 16025 var get = function (prop) { 16026 return state[prop].get(); 16027 }; 16028 var set = function (prop, value) { 16029 state[prop].set(value); 16030 }; 16031 var getValueRgb = function () { 16032 return get('red').bind(function (red) { 16033 return get('green').bind(function (green) { 16034 return get('blue').map(function (blue) { 16035 return rgbaColour(red, green, blue, 1); 16036 }); 16037 }); 16038 }); 16039 }; 16040 var setValueRgb = function (rgb) { 16041 var red = rgb.red; 16042 var green = rgb.green; 16043 var blue = rgb.blue; 16044 set('red', Optional.some(red)); 16045 set('green', Optional.some(green)); 16046 set('blue', Optional.some(blue)); 16047 }; 16048 var onInvalidInput = function (form, simulatedEvent) { 16049 var data = simulatedEvent.event; 16050 if (data.type !== 'hex') { 16051 set(data.type, Optional.none()); 16052 } else { 16053 onInvalidHexx(form); 16054 } 16055 }; 16056 var onValidHex = function (form, value) { 16057 onValidHexx(form); 16058 var hex = hexColour(value); 16059 set('hex', Optional.some(value)); 16060 var rgb = fromHex(hex); 16061 copyRgbToForm(form, rgb); 16062 setValueRgb(rgb); 16063 emitWith(form, fieldsUpdate, { hex: hex }); 16064 updatePreview(form, hex); 16065 }; 16066 var onValidRgb = function (form, prop, value) { 16067 var val = parseInt(value, 10); 16068 set(prop, Optional.some(val)); 16069 getValueRgb().each(function (rgb) { 16070 var hex = copyRgbToHex(form, rgb); 16071 emitWith(form, fieldsUpdate, { hex: hex }); 16072 updatePreview(form, hex); 16073 }); 16074 }; 16075 var isHexInputEvent = function (data) { 16076 return data.type === 'hex'; 16077 }; 16078 var onValidInput = function (form, simulatedEvent) { 16079 var data = simulatedEvent.event; 16080 if (isHexInputEvent(data)) { 16081 onValidHex(form, data.value); 16082 } else { 16083 onValidRgb(form, data.type, data.value); 16084 } 16085 }; 16086 var formPartStrings = function (key) { 16087 return { 16088 label: translate(translatePrefix + key + '.label'), 16089 description: translate(translatePrefix + key + '.description') 16090 }; 16091 }; 16092 var redStrings = formPartStrings('red'); 16093 var greenStrings = formPartStrings('green'); 16094 var blueStrings = formPartStrings('blue'); 16095 var hexStrings = formPartStrings('hex'); 16096 return deepMerge(Form.sketch(function (parts) { 16097 return { 16098 dom: { 16099 tag: 'form', 16100 classes: [getClass('rgb-form')], 16101 attributes: { 'aria-label': translate('aria.color.picker') } 16102 }, 16103 components: [ 16104 parts.field('red', FormField.sketch(renderTextField(isRgbaComponent, 'red', redStrings.label, redStrings.description, 255))), 16105 parts.field('green', FormField.sketch(renderTextField(isRgbaComponent, 'green', greenStrings.label, greenStrings.description, 255))), 16106 parts.field('blue', FormField.sketch(renderTextField(isRgbaComponent, 'blue', blueStrings.label, blueStrings.description, 255))), 16107 parts.field('hex', FormField.sketch(renderTextField(isHexString, 'hex', hexStrings.label, hexStrings.description, 'ffffff'))), 16108 memPreview.asSpec() 16109 ], 16110 formBehaviours: derive$1([ 16111 Invalidating.config({ invalidClass: getClass('form-invalid') }), 16112 config('rgb-form-events', [ 16113 run(validInput, onValidInput), 16114 run(invalidInput, onInvalidInput), 16115 run(validatingInput, onInvalidInput) 16116 ]) 16117 ]) 16118 }; 16119 }), { 16120 apis: { 16121 updateHex: function (form, hex) { 16122 Representing.setValue(form, { hex: hex.value }); 16123 copyHexToRgb(form, hex); 16124 updatePreview(form, hex); 16125 } 16126 } 16127 }); 16128 }; 16129 var rgbFormSketcher = single$2({ 16130 factory: factory, 16131 name: 'RgbForm', 16132 configFields: [], 16133 apis: { 16134 updateHex: function (apis, form, hex) { 16135 apis.updateHex(form, hex); 16136 } 16137 }, 16138 extraApis: {} 16139 }); 16140 return rgbFormSketcher; 16141 }; 16142 16143 var paletteFactory = function (_translate, getClass) { 16144 var spectrumPart = Slider.parts.spectrum({ 16145 dom: { 16146 tag: 'canvas', 16147 attributes: { role: 'presentation' }, 16148 classes: [getClass('sv-palette-spectrum')] 16149 } 16150 }); 16151 var thumbPart = Slider.parts.thumb({ 16152 dom: { 16153 tag: 'div', 16154 attributes: { role: 'presentation' }, 16155 classes: [getClass('sv-palette-thumb')], 16156 innerHtml: '<div class=' + getClass('sv-palette-inner-thumb') + ' role="presentation"></div>' 16157 } 16158 }); 16159 var setColour = function (canvas, rgba) { 16160 var width = canvas.width, height = canvas.height; 16161 var ctx = canvas.getContext('2d'); 16162 if (ctx === null) { 16163 return; 16164 } 16165 ctx.fillStyle = rgba; 16166 ctx.fillRect(0, 0, width, height); 16167 var grdWhite = ctx.createLinearGradient(0, 0, width, 0); 16168 grdWhite.addColorStop(0, 'rgba(255,255,255,1)'); 16169 grdWhite.addColorStop(1, 'rgba(255,255,255,0)'); 16170 ctx.fillStyle = grdWhite; 16171 ctx.fillRect(0, 0, width, height); 16172 var grdBlack = ctx.createLinearGradient(0, 0, 0, height); 16173 grdBlack.addColorStop(0, 'rgba(0,0,0,0)'); 16174 grdBlack.addColorStop(1, 'rgba(0,0,0,1)'); 16175 ctx.fillStyle = grdBlack; 16176 ctx.fillRect(0, 0, width, height); 16177 }; 16178 var setPaletteHue = function (slider, hue) { 16179 var canvas = slider.components()[0].element.dom; 16180 var hsv = hsvColour(hue, 100, 100); 16181 var rgba = fromHsv(hsv); 16182 setColour(canvas, toString(rgba)); 16183 }; 16184 var setPaletteThumb = function (slider, hex) { 16185 var hsv = fromRgb(fromHex(hex)); 16186 Slider.setValue(slider, { 16187 x: hsv.saturation, 16188 y: 100 - hsv.value 16189 }); 16190 }; 16191 var factory = function (_detail) { 16192 var getInitialValue = constant({ 16193 x: 0, 16194 y: 0 16195 }); 16196 var onChange = function (slider, _thumb, value) { 16197 emitWith(slider, paletteUpdate, { value: value }); 16198 }; 16199 var onInit = function (_slider, _thumb, spectrum, _value) { 16200 setColour(spectrum.element.dom, toString(red)); 16201 }; 16202 var sliderBehaviours = derive$1([ 16203 Composing.config({ find: Optional.some }), 16204 Focusing.config({}) 16205 ]); 16206 return Slider.sketch({ 16207 dom: { 16208 tag: 'div', 16209 attributes: { role: 'presentation' }, 16210 classes: [getClass('sv-palette')] 16211 }, 16212 model: { 16213 mode: 'xy', 16214 getInitialValue: getInitialValue 16215 }, 16216 rounded: false, 16217 components: [ 16218 spectrumPart, 16219 thumbPart 16220 ], 16221 onChange: onChange, 16222 onInit: onInit, 16223 sliderBehaviours: sliderBehaviours 16224 }); 16225 }; 16226 var saturationBrightnessPaletteSketcher = single$2({ 16227 factory: factory, 16228 name: 'SaturationBrightnessPalette', 16229 configFields: [], 16230 apis: { 16231 setHue: function (_apis, slider, hue) { 16232 setPaletteHue(slider, hue); 16233 }, 16234 setThumb: function (_apis, slider, hex) {
16235 setPaletteThumb(slider, hex); 16236 } 16237 }, 16238 extraApis: {} 16239 }); 16240 return saturationBrightnessPaletteSketcher; 16241 }; 16242 16243 var makeFactory = function (translate, getClass) { 16244 var factory = function (detail) { 16245 var rgbForm = rgbFormFactory(translate, getClass, detail.onValidHex, detail.onInvalidHex); 16246 var sbPalette = paletteFactory(translate, getClass); 16247 var hueSliderToDegrees = function (hue) { 16248 return (100 - hue) / 100 * 360; 16249 }; 16250 var hueDegreesToSlider = function (hue) { 16251 return 100 - hue / 360 * 100; 16252 }; 16253 var state = { 16254 paletteRgba: Cell(red), 16255 paletteHue: Cell(0) 16256 }; 16257 var memSlider = record(sliderFactory(translate, getClass)); 16258 var memPalette = record(sbPalette.sketch({})); 16259 var memRgb = record(rgbForm.sketch({})); 16260 var updatePalette = function (anyInSystem, _hex, hue) { 16261 memPalette.getOpt(anyInSystem).each(function (palette) { 16262 sbPalette.setHue(palette, hue); 16263 }); 16264 }; 16265 var updateFields = function (anyInSystem, hex) { 16266 memRgb.getOpt(anyInSystem).each(function (form) { 16267 rgbForm.updateHex(form, hex); 16268 }); 16269 }; 16270 var updateSlider = function (anyInSystem, _hex, hue) { 16271 memSlider.getOpt(anyInSystem).each(function (slider) { 16272 Slider.setValue(slider, { y: hueDegreesToSlider(hue) }); 16273 }); 16274 }; 16275 var updatePaletteThumb = function (anyInSystem, hex) { 16276 memPalette.getOpt(anyInSystem).each(function (palette) { 16277 sbPalette.setThumb(palette, hex); 16278 }); 16279 }; 16280 var updateState = function (hex, hue) { 16281 var rgba = fromHex(hex); 16282 state.paletteRgba.set(rgba); 16283 state.paletteHue.set(hue); 16284 }; 16285 var runUpdates = function (anyInSystem, hex, hue, updates) { 16286 updateState(hex, hue); 16287 each(updates, function (update) { 16288 update(anyInSystem, hex, hue); 16289 }); 16290 }; 16291 var onPaletteUpdate = function () { 16292 var updates = [updateFields]; 16293 return function (form, simulatedEvent) { 16294 var value = simulatedEvent.event.value; 16295 var oldHue = state.paletteHue.get(); 16296 var newHsv = hsvColour(oldHue, value.x, 100 - value.y); 16297 var newHex = hsvToHex(newHsv); 16298 runUpdates(form, newHex, oldHue, updates); 16299 }; 16300 }; 16301 var onSliderUpdate = function () { 16302 var updates = [ 16303 updatePalette, 16304 updateFields 16305 ]; 16306 return function (form, simulatedEvent) { 16307 var hue = hueSliderToDegrees(simulatedEvent.event.value.y); 16308 var oldRgb = state.paletteRgba.get(); 16309 var oldHsv = fromRgb(oldRgb); 16310 var newHsv = hsvColour(hue, oldHsv.saturation, oldHsv.value); 16311 var newHex = hsvToHex(newHsv); 16312 runUpdates(form, newHex, hue, updates); 16313 }; 16314 }; 16315 var onFieldsUpdate = function () { 16316 var updates = [ 16317 updatePalette, 16318 updateSlider, 16319 updatePaletteThumb 16320 ]; 16321 return function (form, simulatedEvent) { 16322 var hex = simulatedEvent.event.hex; 16323 var hsv = hexToHsv(hex); 16324 runUpdates(form, hex, hsv.hue, updates); 16325 }; 16326 }; 16327 return { 16328 uid: detail.uid, 16329 dom: detail.dom, 16330 components: [ 16331 memPalette.asSpec(), 16332 memSlider.asSpec(), 16333 memRgb.asSpec() 16334 ], 16335 behaviours: derive$1([ 16336 config('colour-picker-events', [ 16337 run(fieldsUpdate, onFieldsUpdate()), 16338 run(paletteUpdate, onPaletteUpdate()), 16339 run(sliderUpdate, onSliderUpdate()) 16340 ]), 16341 Composing.config({ 16342 find: function (comp) { 16343 return memRgb.getOpt(comp); 16344 } 16345 }), 16346 Keying.config({ mode: 'acyclic' }) 16347 ]) 16348 }; 16349 }; 16350 var colourPickerSketcher = single$2({ 16351 name: 'ColourPicker', 16352 configFields: [
16353 strict$1('dom'), 16354 defaulted$1('onValidHex', noop), 16355 defaulted$1('onInvalidHex', noop) 16356 ], 16357 factory: factory 16358 }); 16359 return colourPickerSketcher; 16360 }; 16361 16362 var self$1 = function () { 16363 return Composing.config({ find: Optional.some }); 16364 }; 16365 var memento = function (mem) { 16366 return Composing.config({ find: mem.getOpt }); 16367 }; 16368 var childAt = function (index) { 16369 return Composing.config({ 16370 find: function (comp) { 16371 return child(comp.element, index).bind(function (element) { 16372 return comp.getSystem().getByDom(element).toOptional(); 16373 }); 16374 } 16375 }); 16376 }; 16377 var ComposingConfigs = { 16378 self: self$1, 16379 memento: memento, 16380 childAt: childAt 16381 }; 16382 16383 var english = { 16384 'colorcustom.rgb.red.label': 'R', 16385 'colorcustom.rgb.red.description': 'Red component', 16386 'colorcustom.rgb.green.label': 'G', 16387 'colorcustom.rgb.green.description': 'Green component', 16388 'colorcustom.rgb.blue.label': 'B', 16389 'colorcustom.rgb.blue.description': 'Blue component', 16390 'colorcustom.rgb.hex.label': '#', 16391 'colorcustom.rgb.hex.description': 'Hex color code', 16392 'colorcustom.rgb.range': 'Range 0 to 255', 16393 'colorcustom.sb.saturation': 'Saturation', 16394 'colorcustom.sb.brightness': 'Brightness', 16395 'colorcustom.sb.picker': 'Saturation and Brightness Picker', 16396 'colorcustom.sb.palette': 'Saturation and Brightness Palette', 16397 'colorcustom.sb.instructions': 'Use arrow keys to select saturation and brightness, on x and y axes', 16398 'colorcustom.hue.hue': 'Hue', 16399 'colorcustom.hue.slider': 'Hue Slider', 16400 'colorcustom.hue.palette': 'Hue Palette', 16401 'colorcustom.hue.instructions': 'Use arrow keys to select a hue', 16402 'aria.color.picker': 'Color Picker', 16403 'aria.input.invalid': 'Invalid input' 16404 }; 16405 var getEnglishText = function (key) { 16406 return english[key]; 16407 }; 16408 var translate$1 = function (key) { 16409 return getEnglishText(key); 16410 }; 16411 var renderColorPicker = function (_spec) { 16412 var getClass = function (key) { 16413 return 'tox-' + key; 16414 }; 16415 var colourPickerFactory = makeFactory(translate$1, getClass); 16416 var onValidHex = function (form) { 16417 emitWith(form, formActionEvent, { 16418 name: 'hex-valid', 16419 value: true 16420 }); 16421 }; 16422 var onInvalidHex = function (form) { 16423 emitWith(form, formActionEvent, { 16424 name: 'hex-valid', 16425 value: false 16426 }); 16427 }; 16428 var memPicker = record(colourPickerFactory.sketch({ 16429 dom: { 16430 tag: 'div', 16431 classes: [getClass('color-picker-container')], 16432 attributes: { role: 'presentation' } 16433 }, 16434 onValidHex: onValidHex, 16435 onInvalidHex: onInvalidHex 16436 })); 16437 return { 16438 dom: { tag: 'div' }, 16439 components: [memPicker.asSpec()], 16440 behaviours: derive$1([ 16441 Representing.config({ 16442 store: { 16443 mode: 'manual', 16444 getValue: function (comp) { 16445 var picker = memPicker.get(comp); 16446 var optRgbForm = Composing.getCurrent(picker); 16447 var optHex = optRgbForm.bind(function (rgbForm) { 16448 var formValues = Representing.getValue(rgbForm); 16449 return formValues.hex; 16450 }); 16451 return optHex.map(function (hex) { 16452 return '#' + hex; 16453 }).getOr(''); 16454 }, 16455 setValue: function (comp, newValue) { 16456 var pattern = /^#([a-fA-F0-9]{3}(?:[a-fA-F0-9]{3})?)/; 16457 var m = pattern.exec(newValue); 16458 var picker = memPicker.get(comp); 16459 var optRgbForm = Composing.getCurrent(picker); 16460 optRgbForm.fold(function () { 16461 console.log('Can not find form'); 16462 }, function (rgbForm) { 16463 Representing.setValue(rgbForm, { hex: Optional.from(m[1]).getOr('') }); 16464 Form.getField(rgbForm, 'hex').each(function (hexField) { 16465 emit(hexField, input()); 16466 }); 16467 }); 16468 } 16469 } 16470 }), 16471 ComposingConfigs.self() 16472 ]) 16473 }; 16474 }; 16475 16476 var global$b = tinymce.util.Tools.resolve('tinymce.Resource'); 16477
16478 var isOldCustomEditor = function (spec) { 16479 return Object.prototype.hasOwnProperty.call(spec, 'init'); 16480 }; 16481 var renderCustomEditor = function (spec) { 16482 var editorApi = Cell(Optional.none()); 16483 var memReplaced = record({ dom: { tag: spec.tag } }); 16484 var initialValue = Cell(Optional.none()); 16485 return { 16486 dom: { 16487 tag: 'div', 16488 classes: ['tox-custom-editor'] 16489 }, 16490 behaviours: derive$1([ 16491 config('custom-editor-events', [runOnAttached(function (component) { 16492 memReplaced.getOpt(component).each(function (ta) { 16493 (isOldCustomEditor(spec) ? spec.init(ta.element.dom) : global$b.load(spec.scriptId, spec.scriptUrl).then(function (init) { 16494 return init(ta.element.dom, spec.settings); 16495 })).then(function (ea) { 16496 initialValue.get().each(function (cvalue) { 16497 ea.setValue(cvalue); 16498 }); 16499 initialValue.set(Optional.none()); 16500 editorApi.set(Optional.some(ea)); 16501 }); 16502 }); 16503 })]), 16504 Representing.config({ 16505 store: { 16506 mode: 'manual', 16507 getValue: function () { 16508 return editorApi.get().fold(function () { 16509 return initialValue.get().getOr(''); 16510 }, function (ed) { 16511 return ed.getValue(); 16512 }); 16513 }, 16514 setValue: function (component, value) { 16515 editorApi.get().fold(function () { 16516 initialValue.set(Optional.some(value)); 16517 }, function (ed) { 16518 return ed.setValue(value); 16519 }); 16520 } 16521 } 16522 }), 16523 ComposingConfigs.self() 16524 ]), 16525 components: [memReplaced.asSpec()] 16526 }; 16527 }; 16528 16529 var global$c = tinymce.util.Tools.resolve('tinymce.util.Tools'); 16530 16531 var processors = objOf([ 16532 defaulted$1('preprocess', identity), 16533 defaulted$1('postprocess', identity) 16534 ]); 16535 var memento$1 = function (mem, rawProcessors) { 16536 var ps = asRawOrDie('RepresentingConfigs.memento processors', processors, rawProcessors); 16537 return Representing.config({ 16538 store: { 16539 mode: 'manual', 16540 getValue: function (comp) { 16541 var other = mem.get(comp); 16542 var rawValue = Representing.getValue(other); 16543 return ps.postprocess(rawValue); 16544 }, 16545 setValue: function (comp, rawValue) { 16546 var newValue = ps.preprocess(rawValue); 16547 var other = mem.get(comp); 16548 Representing.setValue(other, newValue); 16549 } 16550 } 16551 }); 16552 }; 16553 var withComp = function (optInitialValue, getter, setter) { 16554 return Representing.config(deepMerge({ 16555 store: { 16556 mode: 'manual', 16557 getValue: getter, 16558 setValue: setter 16559 } 16560 }, optInitialValue.map(function (initialValue) { 16561 return { store: { initialValue: initialValue } }; 16562 }).getOr({}))); 16563 }; 16564 var withElement = function (initialValue, getter, setter) { 16565 return withComp(initialValue, function (c) { 16566 return getter(c.element); 16567 }, function (c, v) { 16568 return setter(c.element, v); 16569 }); 16570 }; 16571 var domValue = function (optInitialValue) { 16572 return withElement(optInitialValue, get$6, set$3); 16573 }; 16574 var domHtml = function (optInitialValue) { 16575 return withElement(optInitialValue, get$2, set); 16576 }; 16577 var memory$1 = function (initialValue) { 16578 return Representing.config({ 16579 store: { 16580 mode: 'memory', 16581 initialValue: initialValue 16582 } 16583 }); 16584 }; 16585 var RepresentingConfigs = { 16586 memento: memento$1, 16587 withElement: withElement, 16588 withComp: withComp, 16589 domValue: domValue, 16590 domHtml: domHtml, 16591 memory: memory$1 16592 }; 16593 16594 var defaultImageFileTypes = 'jpeg,jpg,jpe,jfi,jif,jfif,png,gif,bmp,webp'; 16595 var filterByExtension = function (files, providersBackstage) { 16596 var allowedImageFileTypes = global$c.explode(providersBackstage.getSetting('images_file_types', defaultImageFileTypes, 'string')); 16597 var isFileInAllowedTypes = function (file) { 16598 return exists(allowedImageFileTypes, function (type) { 16599 return endsWith(file.name.toLowerCase(), '.' + type.toLowerCase()); 16600 }); 16601 }; 16602 return filter(from$1(files), isFileInAllowedTypes); 16603 }; 16604 var renderDropZone = function (spec, providersBackstage) { 16605 var stopper = function (_, se) { 16606 se.stop(); 16607 }; 16608 var sequence = function (actions) { 16609 return function (comp, se) { 16610 each(actions, function (a) { 16611 a(comp, se); 16612 }); 16613 }; 16614 }; 16615 var onDrop = function (comp, se) { 16616 if (!Disabling.isDisabled(comp)) { 16617 var transferEvent = se.event.raw; 16618 handleFiles(comp, transferEvent.dataTransfer.files); 16619 } 16620 }; 16621 var onSelect = function (component, simulatedEvent) { 16622 var input = simulatedEvent.event.raw.target; 16623 handleFiles(component, input.files); 16624 }; 16625 var handleFiles = function (component, files) { 16626 Representing.setValue(component, filterByExtension(files, providersBackstage)); 16627 emitWith(component, formChangeEvent, { name: spec.name }); 16628 }; 16629 var memInput = record({ 16630 dom: { 16631 tag: 'input', 16632 attributes: { 16633 type: 'file', 16634 accept: 'image/*' 16635 }, 16636 styles: { display: 'none' } 16637 },
16638 behaviours: derive$1([config('input-file-events', [ 16639 cutter(click()), 16640 cutter(tap()) 16641 ])]) 16642 }); 16643 var renderField = function (s) { 16644 return { 16645 uid: s.uid, 16646 dom: { 16647 tag: 'div', 16648 classes: ['tox-dropzone-container'] 16649 }, 16650 behaviours: derive$1([ 16651 RepresentingConfigs.memory([]), 16652 ComposingConfigs.self(), 16653 Disabling.config({}), 16654 Toggling.config({ 16655 toggleClass: 'dragenter', 16656 toggleOnExecute: false 16657 }), 16658 config('dropzone-events', [ 16659 run('dragenter', sequence([ 16660 stopper, 16661 Toggling.toggle 16662 ])), 16663 run('dragleave', sequence([ 16664 stopper, 16665 Toggling.toggle 16666 ])), 16667 run('dragover', stopper), 16668 run('drop', sequence([ 16669 stopper, 16670 onDrop 16671 ])), 16672 run(change(), onSelect) 16673 ]) 16674 ]), 16675 components: [{ 16676 dom: { 16677 tag: 'div', 16678 classes: ['tox-dropzone'], 16679 styles: {} 16680 }, 16681 components: [ 16682 { 16683 dom: { 16684 tag: 'p', 16685 innerHtml: providersBackstage.translate('Drop an image here') 16686 } 16687 }, 16688 Button.sketch({ 16689 dom: { 16690 tag: 'button', 16691 innerHtml: providersBackstage.translate('Browse for an image'), 16692 styles: { position: 'relative' }, 16693 classes: [ 16694 'tox-button', 16695 'tox-button--secondary' 16696 ] 16697 }, 16698 components: [memInput.asSpec()], 16699 action: function (comp) { 16700 var inputComp = memInput.get(comp); 16701 inputComp.element.dom.click(); 16702 }, 16703 buttonBehaviours: derive$1([ 16704 Tabstopping.config({}), 16705 DisablingConfigs.button(providersBackstage.isDisabled), 16706 receivingConfig() 16707 ]) 16708 }) 16709 ] 16710 }] 16711 }; 16712 }; 16713 var pLabel = spec.label.map(function (label) { 16714 return renderLabel(label, providersBackstage); 16715 }); 16716 var pField = FormField.parts.field({ factory: { sketch: renderField } }); 16717 return renderFormFieldWith(pLabel, pField, ['tox-form__group--stretched'], []); 16718 }; 16719 16720 var renderGrid = function (spec, backstage) { 16721 return { 16722 dom: { 16723 tag: 'div', 16724 classes: [ 16725 'tox-form__grid', 16726 'tox-form__grid--' + spec.columns + 'col' 16727 ] 16728 }, 16729 components: map(spec.items, backstage.interpreter) 16730 }; 16731 }; 16732 16733 var beforeObject = generate$1('alloy-fake-before-tabstop'); 16734 var afterObject = generate$1('alloy-fake-after-tabstop'); 16735 var craftWithClasses = function (classes) { 16736 return { 16737 dom: { 16738 tag: 'div', 16739 styles: { 16740 width: '1px', 16741 height: '1px', 16742 outline: 'none' 16743 }, 16744 attributes: { tabindex: '0' }, 16745 classes: classes 16746 }, 16747 behaviours: derive$1([ 16748 Focusing.config({ ignore: true }), 16749 Tabstopping.config({}) 16750 ]) 16751 }; 16752 }; 16753 var craft = function (spec) { 16754 return { 16755 dom: { 16756 tag: 'div', 16757 classes: ['tox-navobj'] 16758 }, 16759 components: [ 16760 craftWithClasses([beforeObject]), 16761 spec, 16762 craftWithClasses([afterObject]) 16763 ], 16764 behaviours: derive$1([ComposingConfigs.childAt(1)]) 16765 }; 16766 }; 16767 var triggerTab = function (placeholder, shiftKey) { 16768 emitWith(placeholder, keydown(), { 16769 raw: { 16770 which: 9, 16771 shiftKey: shiftKey 16772 } 16773 }); 16774 }; 16775 var onFocus$1 = function (container, targetComp) { 16776 var target = targetComp.element; 16777 if (has$2(target, beforeObject)) { 16778 triggerTab(container, true); 16779 } else if (has$2(target, afterObject)) { 16780 triggerTab(container, false); 16781 } 16782 }; 16783 var isPseudoStop = function (element) { 16784 return closest$4(element, [ 16785 '.' + beforeObject, 16786 '.' + afterObject 16787 ].join(','), never); 16788 }; 16789 16790 var platformNeedsSandboxing = !(detect$3().browser.isIE() || detect$3().browser.isEdge()); 16791 var getDynamicSource = function (isSandbox) { 16792 var cachedValue = Cell(''); 16793 return { 16794 getValue: function (_frameComponent) { 16795 return cachedValue.get(); 16796 },
16797 setValue: function (frameComponent, html) { 16798 if (!isSandbox) { 16799 set$1(frameComponent.element, 'src', 'javascript:\'\''); 16800 var doc = frameComponent.element.dom.contentWindow.document; 16801 doc.open(); 16802 doc.write(html); 16803 doc.close(); 16804 } else { 16805 set$1(frameComponent.element, 'srcdoc', html); 16806 } 16807 cachedValue.set(html); 16808 } 16809 }; 16810 }; 16811 var renderIFrame = function (spec, providersBackstage) { 16812 var isSandbox = platformNeedsSandboxing && spec.sandboxed; 16813 var attributes = __assign(__assign({}, spec.label.map(function (title) { 16814 return { title: title }; 16815 }).getOr({})), isSandbox ? { sandbox: 'allow-scripts allow-same-origin' } : {}); 16816 var sourcing = getDynamicSource(isSandbox); 16817 var pLabel = spec.label.map(function (label) { 16818 return renderLabel(label, providersBackstage); 16819 }); 16820 var factory = function (newSpec) { 16821 return craft({ 16822 uid: newSpec.uid, 16823 dom: { 16824 tag: 'iframe', 16825 attributes: attributes 16826 }, 16827 behaviours: derive$1([ 16828 Tabstopping.config({}), 16829 Focusing.config({}), 16830 RepresentingConfigs.withComp(Optional.none(), sourcing.getValue, sourcing.setValue) 16831 ]) 16832 }); 16833 }; 16834 var pField = FormField.parts.field({ factory: { sketch: factory } }); 16835 return renderFormFieldWith(pLabel, pField, ['tox-form__group--stretched'], []); 16836 }; 16837 16838 var create$5 = function (width, height) { 16839 return resize(document.createElement('canvas'), width, height); 16840 }; 16841 var clone$1 = function (canvas) { 16842 var tCanvas = create$5(canvas.width, canvas.height); 16843 var ctx = get2dContext(tCanvas); 16844 ctx.drawImage(canvas, 0, 0); 16845 return tCanvas; 16846 }; 16847 var get2dContext = function (canvas) { 16848 return canvas.getContext('2d'); 16849 }; 16850 var resize = function (canvas, width, height) { 16851 canvas.width = width; 16852 canvas.height = height; 16853 return canvas; 16854 }; 16855 16856 var getWidth = function (image) { 16857 return image.naturalWidth || image.width; 16858 }; 16859 var getHeight = function (image) { 16860 return image.naturalHeight || image.height; 16861 }; 16862 16863 var promise = function () { 16864 var Promise = function (fn) { 16865 if (typeof this !== 'object') { 16866 throw new TypeError('Promises must be constructed via new'); 16867 } 16868 if (typeof fn !== 'function') { 16869 throw new TypeError('not a function'); 16870 } 16871 this._state = null; 16872 this._value = null; 16873 this._deferreds = []; 16874 doResolve(fn, bind(resolve, this), bind(reject, this)); 16875 }; 16876 var anyWindow = window; 16877 var asap = Promise.immediateFn || typeof anyWindow.setImmediate === 'function' && anyWindow.setImmediate || function (fn) { 16878 return setTimeout(fn, 1); 16879 }; 16880 var bind = function (fn, thisArg) { 16881 return function () { 16882 var args = []; 16883 for (var _i = 0; _i < arguments.length; _i++) { 16884 args[_i] = arguments[_i]; 16885 } 16886 return fn.apply(thisArg, args); 16887 }; 16888 }; 16889 var isArray = Array.isArray || function (value) { 16890 return Object.prototype.toString.call(value) === '[object Array]'; 16891 }; 16892 function handle(deferred) { 16893 var me = this; 16894 if (this._state === null) { 16895 this._deferreds.push(deferred); 16896 return; 16897 } 16898 asap(function () { 16899 var cb = me._state ? deferred.onFulfilled : deferred.onRejected; 16900 if (cb === null) { 16901 (me._state ? deferred.resolve : deferred.reject)(me._value); 16902 return; 16903 } 16904 var ret; 16905 try { 16906 ret = cb(me._value); 16907 } catch (e) { 16908 deferred.reject(e); 16909 return; 16910 } 16911 deferred.resolve(ret); 16912 }); 16913 } 16914 function resolve(newValue) { 16915 try { 16916 if (newValue === this) { 16917 throw new TypeError('A promise cannot be resolved with itself.'); 16918 } 16919 if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) { 16920 var then = newValue.then; 16921 if (typeof then === 'function') { 16922 doResolve(bind(then, newValue), bind(resolve, this), bind(reject, this)); 16923 return; 16924 } 16925 } 16926 this._state = true; 16927 this._value = newValue; 16928 finale.call(this); 16929 } catch (e) { 16930 reject.call(this, e); 16931 } 16932 } 16933 function reject(newValue) { 16934 this._state = false;
16935 this._value = newValue; 16936 finale.call(this); 16937 } 16938 function finale() { 16939 for (var _i = 0, _a = this._deferreds; _i < _a.length; _i++) { 16940 var deferred = _a[_i]; 16941 handle.call(this, deferred); 16942 } 16943 this._deferreds = []; 16944 } 16945 function Handler(onFulfilled, onRejected, resolve, reject) { 16946 this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null; 16947 this.onRejected = typeof onRejected === 'function' ? onRejected : null; 16948 this.resolve = resolve; 16949 this.reject = reject; 16950 } 16951 var doResolve = function (fn, onFulfilled, onRejected) { 16952 var done = false; 16953 try { 16954 fn(function (value) { 16955 if (done) { 16956 return; 16957 } 16958 done = true; 16959 onFulfilled(value); 16960 }, function (reason) { 16961 if (done) { 16962 return; 16963 } 16964 done = true; 16965 onRejected(reason); 16966 }); 16967 } catch (ex) { 16968 if (done) { 16969 return; 16970 } 16971 done = true; 16972 onRejected(ex); 16973 } 16974 }; 16975 Promise.prototype.catch = function (onRejected) { 16976 return this.then(null, onRejected); 16977 }; 16978 Promise.prototype.then = function (onFulfilled, onRejected) { 16979 var me = this; 16980 return new Promise(function (resolve, reject) { 16981 handle.call(me, new Handler(onFulfilled, onRejected, resolve, reject)); 16982 }); 16983 }; 16984 Promise.all = function () { 16985 var values = []; 16986 for (var _i = 0; _i < arguments.length; _i++) { 16987 values[_i] = arguments[_i]; 16988 } 16989 var args = Array.prototype.slice.call(values.length === 1 && isArray(values[0]) ? values[0] : values); 16990 return new Promise(function (resolve, reject) { 16991 if (args.length === 0) { 16992 return resolve([]); 16993 } 16994 var remaining = args.length; 16995 var res = function (i, val) { 16996 try { 16997 if (val && (typeof val === 'object' || typeof val === 'function')) { 16998 var then = val.then; 16999 if (typeof then === 'function') { 17000 then.call(val, function (val) { 17001 res(i, val); 17002 }, reject); 17003 return; 17004 } 17005 } 17006 args[i] = val; 17007 if (--remaining === 0) { 17008 resolve(args); 17009 } 17010 } catch (ex) { 17011 reject(ex); 17012 } 17013 }; 17014 for (var i = 0; i < args.length; i++) { 17015 res(i, args[i]); 17016 } 17017 }); 17018 }; 17019 Promise.resolve = function (value) { 17020 if (value && typeof value === 'object' && value.constructor === Promise) { 17021 return value; 17022 } 17023 return new Promise(function (resolve) { 17024 resolve(value); 17025 }); 17026 }; 17027 Promise.reject = function (reason) { 17028 return new Promise(function (resolve, reject) { 17029 reject(reason); 17030 }); 17031 }; 17032 Promise.race = function (values) { 17033 return new Promise(function (resolve, reject) { 17034 for (var _i = 0, values_1 = values; _i < values_1.length; _i++) { 17035 var value = values_1[_i]; 17036 value.then(resolve, reject); 17037 } 17038 }); 17039 }; 17040 return Promise; 17041 }; 17042 var Promise$1 = window.Promise ? window.Promise : promise(); 17043 17044 var blobToImage = function (blob) { 17045 return new Promise$1(function (resolve, reject) { 17046 var blobUrl = URL.createObjectURL(blob); 17047 var image = new Image(); 17048 var removeListeners = function () { 17049 image.removeEventListener('load', loaded); 17050 image.removeEventListener('error', error); 17051 }; 17052 var loaded = function () { 17053 removeListeners(); 17054 resolve(image); 17055 }; 17056 var error = function () { 17057 removeListeners(); 17058 reject('Unable to load data of type ' + blob.type + ': ' + blobUrl); 17059 }; 17060 image.addEventListener('load', loaded); 17061 image.addEventListener('error', error); 17062 image.src = blobUrl; 17063 if (image.complete) { 17064 setTimeout(loaded, 0); 17065 } 17066 }); 17067 }; 17068 var dataUriToBlobSync = function (uri) { 17069 var data = uri.split(','); 17070 var matches = /data:([^;]+)/.exec(data[0]); 17071 if (!matches) { 17072 return Optional.none(); 17073 } 17074 var mimetype = matches[1]; 17075 var base64 = data[1]; 17076 var sliceSize = 1024; 17077 var byteCharacters = atob(base64); 17078 var bytesLength = byteCharacters.length;
17079 var slicesCount = Math.ceil(bytesLength / sliceSize); 17080 var byteArrays = new Array(slicesCount); 17081 for (var sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) { 17082 var begin = sliceIndex * sliceSize; 17083 var end = Math.min(begin + sliceSize, bytesLength); 17084 var bytes = new Array(end - begin); 17085 for (var offset = begin, i = 0; offset < end; ++i, ++offset) { 17086 bytes[i] = byteCharacters[offset].charCodeAt(0); 17087 } 17088 byteArrays[sliceIndex] = new Uint8Array(bytes); 17089 } 17090 return Optional.some(new Blob(byteArrays, { type: mimetype })); 17091 }; 17092 var dataUriToBlob = function (uri) { 17093 return new Promise$1(function (resolve, reject) { 17094 dataUriToBlobSync(uri).fold(function () { 17095 reject('uri is not base64: ' + uri); 17096 }, resolve); 17097 }); 17098 }; 17099 var canvasToBlob = function (canvas, type, quality) { 17100 type = type || 'image/png'; 17101 if (isFunction(HTMLCanvasElement.prototype.toBlob)) { 17102 return new Promise$1(function (resolve, reject) { 17103 canvas.toBlob(function (blob) { 17104 if (blob) { 17105 resolve(blob); 17106 } else { 17107 reject(); 17108 } 17109 }, type, quality); 17110 }); 17111 } else { 17112 return dataUriToBlob(canvas.toDataURL(type, quality)); 17113 } 17114 }; 17115 var canvasToDataURL = function (canvas, type, quality) { 17116 type = type || 'image/png'; 17117 return canvas.toDataURL(type, quality); 17118 }; 17119 var blobToCanvas = function (blob) { 17120 return blobToImage(blob).then(function (image) { 17121 revokeImageUrl(image); 17122 var canvas = create$5(getWidth(image), getHeight(image)); 17123 var context = get2dContext(canvas); 17124 context.drawImage(image, 0, 0); 17125 return canvas; 17126 }); 17127 }; 17128 var blobToDataUri = function (blob) { 17129 return new Promise$1(function (resolve) { 17130 var reader = new FileReader(); 17131 reader.onloadend = function () { 17132 resolve(reader.result); 17133 }; 17134 reader.readAsDataURL(blob); 17135 }); 17136 }; 17137 var revokeImageUrl = function (image) { 17138 URL.revokeObjectURL(image.src); 17139 }; 17140 17141 var create$6 = function (getCanvas, blob, uri) { 17142 var initialType = blob.type; 17143 var getType = constant(initialType); 17144 var toBlob = function () { 17145 return Promise$1.resolve(blob); 17146 }; 17147 var toDataURL = constant(uri); 17148 var toBase64 = function () { 17149 return uri.split(',')[1]; 17150 }; 17151 var toAdjustedBlob = function (type, quality) { 17152 return getCanvas.then(function (canvas) { 17153 return canvasToBlob(canvas, type, quality); 17154 }); 17155 }; 17156 var toAdjustedDataURL = function (type, quality) { 17157 return getCanvas.then(function (canvas) { 17158 return canvasToDataURL(canvas, type, quality); 17159 }); 17160 }; 17161 var toAdjustedBase64 = function (type, quality) { 17162 return toAdjustedDataURL(type, quality).then(function (dataurl) { 17163 return dataurl.split(',')[1]; 17164 }); 17165 }; 17166 var toCanvas = function () { 17167 return getCanvas.then(clone$1); 17168 }; 17169 return { 17170 getType: getType, 17171 toBlob: toBlob, 17172 toDataURL: toDataURL, 17173 toBase64: toBase64, 17174 toAdjustedBlob: toAdjustedBlob, 17175 toAdjustedDataURL: toAdjustedDataURL, 17176 toAdjustedBase64: toAdjustedBase64, 17177 toCanvas: toCanvas 17178 }; 17179 }; 17180 var fromBlob = function (blob) { 17181 return blobToDataUri(blob).then(function (uri) { 17182 return create$6(blobToCanvas(blob), blob, uri); 17183 }); 17184 }; 17185 var fromCanvas = function (canvas, type) { 17186 return canvasToBlob(canvas, type).then(function (blob) { 17187 return create$6(Promise$1.resolve(canvas), blob, canvas.toDataURL()); 17188 }); 17189 }; 17190 17191 var blobToImageResult = function (blob) { 17192 return fromBlob(blob); 17193 }; 17194 17195 var clamp$1 = function (value, min, max) { 17196 var parsedValue = typeof value === 'string' ? parseFloat(value) : value; 17197 if (parsedValue > max) { 17198 parsedValue = max; 17199 } else if (parsedValue < min) { 17200 parsedValue = min; 17201 } 17202 return parsedValue; 17203 }; 17204 var identity$1 = function () { 17205 return [ 17206 1, 17207 0, 17208 0, 17209 0, 17210 0, 17211 0, 17212 1, 17213 0, 17214 0, 17215 0, 17216 0, 17217 0, 17218 1, 17219 0, 17220 0, 17221 0, 17222 0, 17223 0, 17224 1, 17225 0, 17226 0, 17227 0, 17228 0, 17229 0, 17230 1 17231 ]; 17232 }; 17233 var DELTA_INDEX = [ 17234 0, 17235 0.01, 17236 0.02, 17237 0.04, 17238 0.05, 17239 0.06, 17240 0.07, 17241 0.08, 17242 0.1, 17243 0.11, 17244 0.12, 17245 0.14, 17246 0.15, 17247 0.16, 17248 0.17, 17249 0.18, 17250 0.2, 17251 0.21, 17252 0.22, 17253 0.24, 17254 0.25, 17255 0.27, 17256 0.28, 17257 0.3, 17258 0.32, 17259 0.34, 17260 0.36, 17261 0.38, 17262 0.4, 17263 0.42, 17264 0.44, 17265 0.46, 17266 0.48, 17267 0.5, 17268 0.53, 17269 0.56, 17270 0.59, 17271 0.62, 17272 0.65, 17273 0.68, 17274 0.71, 17275 0.74, 17276 0.77, 17277 0.8, 17278 0.83, 17279 0.86, 17280 0.89, 17281 0.92, 17282 0.95, 17283 0.98, 17284 1, 17285 1.06, 17286 1.12, 17287 1.18, 17288 1.24, 17289 1.3, 17290 1.36, 17291 1.42, 17292 1.48, 17293 1.54, 17294 1.6, 17295 1.66, 17296 1.72, 17297 1.78, 17298 1.84, 17299 1.9, 17300 1.96, 17301 2, 17302 2.12, 17303 2.25, 17304 2.37, 17305 2.5, 17306 2.62, 17307 2.75, 17308 2.87, 17309 3, 17310 3.2, 17311 3.4, 17312 3.6, 17313 3.8, 17314 4, 17315 4.3, 17316 4.7, 17317 4.9, 17318 5, 17319 5.5, 17320 6, 17321 6.5, 17322 6.8, 17323 7, 17324 7.3, 17325 7.5, 17326 7.8, 17327 8, 17328 8.4, 17329 8.7, 17330 9, 17331 9.4, 17332 9.6, 17333 9.8, 17334 10 17335 ]; 17336 var multiply = function (matrix1, matrix2) { 17337 var col = []; 17338 var out = new Array(25); 17339 var val; 17340 for (var i = 0; i < 5; i++) { 17341 for (var j = 0; j < 5; j++) { 17342 col[j] = matrix2[j + i * 5]; 17343 } 17344 for (var j = 0; j < 5; j++) { 17345 val = 0; 17346 for (var k = 0; k < 5; k++) { 17347 val += matrix1[j + k * 5] * col[k]; 17348 } 17349 out[j + i * 5] = val; 17350 } 17351 } 17352 return out; 17353 }; 17354 var adjustContrast = function (matrix, value) { 17355 var x; 17356 value = clamp$1(value, -1, 1); 17357 value *= 100; 17358 if (value < 0) { 17359 x = 127 + value / 100 * 127; 17360 } else { 17361 x = value % 1; 17362 if (x === 0) { 17363 x = DELTA_INDEX[value]; 17364 } else { 17365 x = DELTA_INDEX[Math.floor(value)] * (1 - x) + DELTA_INDEX[Math.floor(value) + 1] * x; 17366 } 17367 x = x * 127 + 127; 17368 } 17369 return multiply(matrix, [ 17370 x / 127, 17371 0, 17372 0, 17373 0, 17374 0.5 * (127 - x), 17375 0, 17376 x / 127, 17377 0, 17378 0, 17379 0.5 * (127 - x), 17380 0, 17381 0, 17382 x / 127, 17383 0, 17384 0.5 * (127 - x), 17385 0, 17386 0, 17387 0, 17388 1, 17389 0, 17390 0, 17391 0, 17392 0, 17393 0, 17394 1 17395 ]); 17396 }; 17397 var adjustBrightness = function (matrix, value) { 17398 value = clamp$1(255 * value, -255, 255); 17399 return multiply(matrix, [ 17400 1, 17401 0, 17402 0, 17403 0, 17404 value, 17405 0, 17406 1, 17407 0, 17408 0, 17409 value, 17410 0, 17411 0, 17412 1, 17413 0, 17414 value, 17415 0, 17416 0, 17417 0, 17418 1, 17419 0, 17420 0, 17421 0, 17422 0, 17423 0, 17424 1 17425 ]); 17426 }; 17427 var adjustColors = function (matrix, adjustR, adjustG, adjustB) { 17428 adjustR = clamp$1(adjustR, 0, 2); 17429 adjustG = clamp$1(adjustG, 0, 2); 17430 adjustB = clamp$1(adjustB, 0, 2); 17431 return multiply(matrix, [ 17432 adjustR, 17433 0, 17434 0, 17435 0, 17436 0, 17437 0, 17438 adjustG, 17439 0, 17440 0, 17441 0, 17442 0, 17443 0, 17444 adjustB, 17445 0, 17446 0, 17447 0, 17448 0, 17449 0, 17450 1, 17451 0, 17452 0, 17453 0, 17454 0, 17455 0, 17456 1 17457 ]); 17458 }; 17459
17460 var colorFilter = function (ir, matrix) { 17461 return ir.toCanvas().then(function (canvas) { 17462 return applyColorFilter(canvas, ir.getType(), matrix); 17463 }); 17464 }; 17465 var applyColorFilter = function (canvas, type, matrix) { 17466 var context = get2dContext(canvas); 17467 var applyMatrix = function (pixelsData, m) { 17468 var r, g, b, a; 17469 var data = pixelsData.data, m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3], m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7], m8 = m[8], m9 = m[9], m10 = m[10], m11 = m[11], m12 = m[12], m13 = m[13], m14 = m[14], m15 = m[15], m16 = m[16], m17 = m[17], m18 = m[18], m19 = m[19]; 17470 for (var i = 0; i < data.length; i += 4) { 17471 r = data[i]; 17472 g = data[i + 1]; 17473 b = data[i + 2]; 17474 a = data[i + 3]; 17475 data[i] = r * m0 + g * m1 + b * m2 + a * m3 + m4; 17476 data[i + 1] = r * m5 + g * m6 + b * m7 + a * m8 + m9; 17477 data[i + 2] = r * m10 + g * m11 + b * m12 + a * m13 + m14; 17478 data[i + 3] = r * m15 + g * m16 + b * m17 + a * m18 + m19; 17479 } 17480 return pixelsData; 17481 }; 17482 var pixels = applyMatrix(context.getImageData(0, 0, canvas.width, canvas.height), matrix); 17483 context.putImageData(pixels, 0, 0); 17484 return fromCanvas(canvas, type); 17485 }; 17486 var convoluteFilter = function (ir, matrix) { 17487 return ir.toCanvas().then(function (canvas) { 17488 return applyConvoluteFilter(canvas, ir.getType(), matrix); 17489 }); 17490 }; 17491 var applyConvoluteFilter = function (canvas, type, matrix) { 17492 var context = get2dContext(canvas); 17493 var applyMatrix = function (pIn, pOut, aMatrix) { 17494 var clamp = function (value, min, max) { 17495 if (value > max) { 17496 value = max; 17497 } else if (value < min) { 17498 value = min; 17499 } 17500 return value; 17501 }; 17502 var side = Math.round(Math.sqrt(aMatrix.length)); 17503 var halfSide = Math.floor(side / 2); 17504 var rgba = pIn.data; 17505 var drgba = pOut.data; 17506 var w = pIn.width; 17507 var h = pIn.height; 17508 for (var y = 0; y < h; y++) { 17509 for (var x = 0; x < w; x++) { 17510 var r = 0; 17511 var g = 0; 17512 var b = 0; 17513 for (var cy = 0; cy < side; cy++) { 17514 for (var cx = 0; cx < side; cx++) { 17515 var scx = clamp(x + cx - halfSide, 0, w - 1); 17516 var scy = clamp(y + cy - halfSide, 0, h - 1); 17517 var innerOffset = (scy * w + scx) * 4; 17518 var wt = aMatrix[cy * side + cx]; 17519 r += rgba[innerOffset] * wt; 17520 g += rgba[innerOffset + 1] * wt; 17521 b += rgba[innerOffset + 2] * wt; 17522 } 17523 } 17524 var offset = (y * w + x) * 4; 17525 drgba[offset] = clamp(r, 0, 255); 17526 drgba[offset + 1] = clamp(g, 0, 255); 17527 drgba[offset + 2] = clamp(b, 0, 255); 17528 } 17529 } 17530 return pOut; 17531 }; 17532 var pixelsIn = context.getImageData(0, 0, canvas.width, canvas.height); 17533 var pixelsOut = context.getImageData(0, 0, canvas.width, canvas.height); 17534 pixelsOut = applyMatrix(pixelsIn, pixelsOut, matrix); 17535 context.putImageData(pixelsOut, 0, 0); 17536 return fromCanvas(canvas, type); 17537 }; 17538 var functionColorFilter = function (colorFn) { 17539 var filterImpl = function (canvas, type, value) { 17540 var context = get2dContext(canvas); 17541 var lookup = new Array(256); 17542 var applyLookup = function (pixelsData, lookupData) { 17543 var data = pixelsData.data; 17544 for (var i = 0; i < data.length; i += 4) { 17545 data[i] = lookupData[data[i]]; 17546 data[i + 1] = lookupData[data[i + 1]]; 17547 data[i + 2] = lookupData[data[i + 2]]; 17548 } 17549 return pixelsData; 17550 }; 17551 for (var i = 0; i < lookup.length; i++) { 17552 lookup[i] = colorFn(i, value); 17553 } 17554 var pixels = applyLookup(context.getImageData(0, 0, canvas.width, canvas.height), lookup); 17555 context.putImageData(pixels, 0, 0); 17556 return fromCanvas(canvas, type); 17557 }; 17558 return function (ir, value) { 17559 return ir.toCanvas().then(function (canvas) { 17560 return filterImpl(canvas, ir.getType(), value); 17561 }); 17562 }; 17563 }; 17564 var complexAdjustableColorFilter = function (matrixAdjustFn) { 17565 return function (ir, adjust) { 17566 return colorFilter(ir, matrixAdjustFn(identity$1(), adjust)); 17567 }; 17568 }; 17569 var basicColorFilter = function (matrix) { 17570 return function (ir) {
17571 return colorFilter(ir, matrix); 17572 }; 17573 }; 17574 var basicConvolutionFilter = function (kernel) { 17575 return function (ir) { 17576 return convoluteFilter(ir, kernel); 17577 }; 17578 }; 17579 var invert = basicColorFilter([ 17580 -1, 17581 0, 17582 0, 17583 0, 17584 255, 17585 0, 17586 -1, 17587 0, 17588 0, 17589 255, 17590 0, 17591 0, 17592 -1, 17593 0, 17594 255, 17595 0, 17596 0, 17597 0, 17598 1, 17599 0, 17600 0, 17601 0, 17602 0, 17603 0, 17604 1 17605 ]); 17606 var brightness = complexAdjustableColorFilter(adjustBrightness); 17607 var contrast = complexAdjustableColorFilter(adjustContrast); 17608 var colorize = function (ir, adjustR, adjustG, adjustB) { 17609 return colorFilter(ir, adjustColors(identity$1(), adjustR, adjustG, adjustB)); 17610 }; 17611 var sharpen = basicConvolutionFilter([ 17612 0, 17613 -1, 17614 0, 17615 -1, 17616 5, 17617 -1, 17618 0, 17619 -1, 17620 0 17621 ]); 17622 var gamma = functionColorFilter(function (color, value) { 17623 return Math.pow(color / 255, 1 - value) * 255; 17624 }); 17625 17626 var scale = function (image, dW, dH) { 17627 var sW = getWidth(image); 17628 var sH = getHeight(image); 17629 var wRatio = dW / sW; 17630 var hRatio = dH / sH; 17631 var scaleCapped = false; 17632 if (wRatio < 0.5 || wRatio > 2) { 17633 wRatio = wRatio < 0.5 ? 0.5 : 2; 17634 scaleCapped = true; 17635 } 17636 if (hRatio < 0.5 || hRatio > 2) { 17637 hRatio = hRatio < 0.5 ? 0.5 : 2; 17638 scaleCapped = true; 17639 } 17640 var scaled = _scale(image, wRatio, hRatio); 17641 return !scaleCapped ? scaled : scaled.then(function (tCanvas) { 17642 return scale(tCanvas, dW, dH); 17643 }); 17644 }; 17645 var _scale = function (image, wRatio, hRatio) { 17646 return new Promise$1(function (resolve) { 17647 var sW = getWidth(image); 17648 var sH = getHeight(image); 17649 var dW = Math.floor(sW * wRatio); 17650 var dH = Math.floor(sH * hRatio); 17651 var canvas = create$5(dW, dH); 17652 var context = get2dContext(canvas); 17653 context.drawImage(image, 0, 0, sW, sH, 0, 0, dW, dH); 17654 resolve(canvas); 17655 }); 17656 }; 17657 17658 var ceilWithPrecision = function (num, precision) { 17659 if (precision === void 0) { 17660 precision = 2; 17661 } 17662 var mul = Math.pow(10, precision); 17663 var upper = Math.round(num * mul); 17664 return Math.ceil(upper / mul); 17665 }; 17666 var rotate = function (ir, angle) { 17667 return ir.toCanvas().then(function (canvas) { 17668 return applyRotate(canvas, ir.getType(), angle); 17669 }); 17670 }; 17671 var applyRotate = function (image, type, angle) { 17672 var degrees = angle < 0 ? 360 + angle : angle; 17673 var rad = degrees * Math.PI / 180; 17674 var width = image.width; 17675 var height = image.height; 17676 var sin = Math.sin(rad); 17677 var cos = Math.cos(rad); 17678 var newWidth = ceilWithPrecision(Math.abs(width * cos) + Math.abs(height * sin)); 17679 var newHeight = ceilWithPrecision(Math.abs(width * sin) + Math.abs(height * cos)); 17680 var canvas = create$5(newWidth, newHeight); 17681 var context = get2dContext(canvas); 17682 context.translate(newWidth / 2, newHeight / 2); 17683 context.rotate(rad); 17684 context.drawImage(image, -width / 2, -height / 2); 17685 return fromCanvas(canvas, type); 17686 }; 17687 var flip = function (ir, axis) { 17688 return ir.toCanvas().then(function (canvas) { 17689 return applyFlip(canvas, ir.getType(), axis); 17690 }); 17691 }; 17692 var applyFlip = function (image, type, axis) { 17693 var canvas = create$5(image.width, image.height); 17694 var context = get2dContext(canvas); 17695 if (axis === 'v') { 17696 context.scale(1, -1); 17697 context.drawImage(image, 0, -canvas.height); 17698 } else { 17699 context.scale(-1, 1); 17700 context.drawImage(image, -canvas.width, 0); 17701 } 17702 return fromCanvas(canvas, type); 17703 }; 17704 var crop = function (ir, x, y, w, h) { 17705 return ir.toCanvas().then(function (canvas) { 17706 return applyCrop(canvas, ir.getType(), x, y, w, h); 17707 }); 17708 }; 17709 var applyCrop = function (image, type, x, y, w, h) { 17710 var canvas = create$5(w, h); 17711 var context = get2dContext(canvas); 17712 context.drawImage(image, -x, -y); 17713 return fromCanvas(canvas, type); 17714 }; 17715 var resize$1 = function (ir, w, h) { 17716 return ir.toCanvas().then(function (canvas) { 17717 return scale(canvas, w, h).then(function (newCanvas) { 17718 return fromCanvas(newCanvas, ir.getType()); 17719 }); 17720 }); 17721 }; 17722 17723 var invert$1 = function (ir) { 17724 return invert(ir); 17725 };
17726 var sharpen$1 = function (ir) { 17727 return sharpen(ir); 17728 }; 17729 var gamma$1 = function (ir, value) { 17730 return gamma(ir, value); 17731 }; 17732 var colorize$1 = function (ir, adjustR, adjustG, adjustB) { 17733 return colorize(ir, adjustR, adjustG, adjustB); 17734 }; 17735 var brightness$1 = function (ir, adjust) { 17736 return brightness(ir, adjust); 17737 }; 17738 var contrast$1 = function (ir, adjust) { 17739 return contrast(ir, adjust); 17740 }; 17741 var flip$1 = function (ir, axis) { 17742 return flip(ir, axis); 17743 }; 17744 var crop$1 = function (ir, x, y, w, h) { 17745 return crop(ir, x, y, w, h); 17746 }; 17747 var resize$2 = function (ir, w, h) { 17748 return resize$1(ir, w, h); 17749 }; 17750 var rotate$1 = function (ir, angle) { 17751 return rotate(ir, angle); 17752 }; 17753 17754 var renderIcon$1 = function (iconHtml, behaviours) { 17755 return __assign({ 17756 dom: { 17757 tag: 'span', 17758 innerHtml: iconHtml, 17759 classes: [ 17760 'tox-icon', 17761 'tox-tbtn__icon-wrap' 17762 ] 17763 } 17764 }, behaviours); 17765 }; 17766 var renderIconFromPack = function (iconName, iconsProvider) { 17767 return renderIcon$1(get$e(iconName, iconsProvider), {}); 17768 }; 17769 var renderReplacableIconFromPack = function (iconName, iconsProvider) { 17770 return renderIcon$1(get$e(iconName, iconsProvider), { behaviours: derive$1([Replacing.config({})]) }); 17771 }; 17772 var renderLabel$1 = function (text, prefix, providersBackstage) { 17773 return { 17774 dom: { 17775 tag: 'span', 17776 innerHtml: providersBackstage.translate(text), 17777 classes: [prefix + '__select-label'] 17778 }, 17779 behaviours: derive$1([Replacing.config({})]) 17780 }; 17781 }; 17782 17783 var _a$1; 17784 var internalToolbarButtonExecute = generate$1('toolbar.button.execute'); 17785 var onToolbarButtonExecute = function (info) { 17786 return runOnExecute(function (comp, _simulatedEvent) { 17787 runWithApi(info, comp)(function (itemApi) { 17788 emitWith(comp, internalToolbarButtonExecute, { buttonApi: itemApi }); 17789 info.onAction(itemApi); 17790 }); 17791 }); 17792 }; 17793 var toolbarButtonEventOrder = (_a$1 = {}, _a$1[execute()] = [ 17794 'disabling', 17795 'alloy.base.behaviour', 17796 'toggling', 17797 'toolbar-button-events' 17798 ], _a$1); 17799 17800 var updateMenuText = generate$1('update-menu-text'); 17801 var updateMenuIcon = generate$1('update-menu-icon'); 17802 var renderCommonDropdown = function (spec, prefix, sharedBackstage) { 17803 var editorOffCell = Cell(noop); 17804 var optMemDisplayText = spec.text.map(function (text) { 17805 return record(renderLabel$1(text, prefix, sharedBackstage.providers)); 17806 }); 17807 var optMemDisplayIcon = spec.icon.map(function (iconName) { 17808 return record(renderReplacableIconFromPack(iconName, sharedBackstage.providers.icons)); 17809 }); 17810 var onLeftOrRightInMenu = function (comp, se) { 17811 var dropdown = Representing.getValue(comp); 17812 Focusing.focus(dropdown); 17813 emitWith(dropdown, 'keydown', { raw: se.event.raw }); 17814 Dropdown.close(dropdown); 17815 return Optional.some(true); 17816 }; 17817 var role = spec.role.fold(function () { 17818 return {}; 17819 }, function (role) { 17820 return { role: role }; 17821 }); 17822 var tooltipAttributes = spec.tooltip.fold(function () { 17823 return {}; 17824 }, function (tooltip) { 17825 var translatedTooltip = sharedBackstage.providers.translate(tooltip); 17826 return { 17827 'title': translatedTooltip, 17828 'aria-label': translatedTooltip 17829 }; 17830 }); 17831 var memDropdown = record(Dropdown.sketch(__assign(__assign(__assign({}, spec.uid ? { uid: spec.uid } : {}), role), { 17832 dom: { 17833 tag: 'button', 17834 classes: [ 17835 prefix, 17836 prefix + '--select' 17837 ].concat(map(spec.classes, function (c) { 17838 return prefix + '--' + c; 17839 })), 17840 attributes: __assign({}, tooltipAttributes) 17841 }, 17842 components: componentRenderPipeline([ 17843 optMemDisplayIcon.map(function (mem) { 17844 return mem.asSpec(); 17845 }), 17846 optMemDisplayText.map(function (mem) { 17847 return mem.asSpec(); 17848 }), 17849 Optional.some({ 17850 dom: { 17851 tag: 'div', 17852 classes: [prefix + '__select-chevron'], 17853 innerHtml: get$e('chevron-down', sharedBackstage.providers.icons) 17854 } 17855 }) 17856 ]), 17857 matchWidth: true, 17858 useMinWidth: true, 17859 dropdownBehaviours: derive$1(__spreadArrays(spec.dropdownBehaviours, [ 17860 DisablingConfigs.button(function () { 17861 return spec.disabled || sharedBackstage.providers.isDisabled(); 17862 }), 17863 receivingConfig(), 17864 Unselecting.config({}), 17865 Replacing.config({}), 17866 config('dropdown-events', [ 17867 onControlAttached(spec, editorOffCell), 17868 onControlDetached(spec, editorOffCell) 17869 ]), 17870 config('menubutton-update-display-text', [ 17871 run(updateMenuText, function (comp, se) { 17872 optMemDisplayText.bind(function (mem) { 17873 return mem.getOpt(comp); 17874 }).each(function (displayText) { 17875 Replacing.set(displayText, [text(sharedBackstage.providers.translate(se.event.text))]); 17876 }); 17877 }), 17878 run(updateMenuIcon, function (comp, se) { 17879 optMemDisplayIcon.bind(function (mem) { 17880 return mem.getOpt(comp); 17881 }).each(function (displayIcon) { 17882 Replacing.set(displayIcon, [renderReplacableIconFromPack(se.event.icon, sharedBackstage.providers.icons)]); 17883 }); 17884 }) 17885 ]) 17886 ])), 17887 eventOrder: deepMerge(toolbarButtonEventOrder, { 17888 mousedown: [
17889 'focusing', 17890 'alloy.base.behaviour', 17891 'item-type-events', 17892 'normal-dropdown-events' 17893 ] 17894 }), 17895 sandboxBehaviours: derive$1([Keying.config({ 17896 mode: 'special', 17897 onLeft: onLeftOrRightInMenu, 17898 onRight: onLeftOrRightInMenu 17899 })]), 17900 lazySink: sharedBackstage.getSink, 17901 toggleClass: prefix + '--active', 17902 parts: { menu: part(false, spec.columns, spec.presets) }, 17903 fetch: function (comp) { 17904 return Future.nu(curry(spec.fetch, comp)); 17905 } 17906 }))); 17907 return memDropdown.asSpec(); 17908 }; 17909 17910 var isMenuItemReference = function (item) { 17911 return isString(item); 17912 }; 17913 var isSeparator = function (item) { 17914 return item.type === 'separator'; 17915 }; 17916 var isExpandingMenuItem = function (item) { 17917 return has(item, 'getSubmenuItems'); 17918 }; 17919 var separator$1 = { type: 'separator' }; 17920 var unwrapReferences = function (items, menuItems) { 17921 var realItems = foldl(items, function (acc, item) { 17922 if (isMenuItemReference(item)) { 17923 if (item === '') { 17924 return acc; 17925 } else if (item === '|') { 17926 return acc.length > 0 && !isSeparator(acc[acc.length - 1]) ? acc.concat([separator$1]) : acc; 17927 } else if (has(menuItems, item.toLowerCase())) { 17928 return acc.concat([menuItems[item.toLowerCase()]]); 17929 } else { 17930 return acc; 17931 } 17932 } else { 17933 return acc.concat([item]); 17934 } 17935 }, []); 17936 if (realItems.length > 0 && isSeparator(realItems[realItems.length - 1])) { 17937 realItems.pop(); 17938 } 17939 return realItems; 17940 }; 17941 var getFromExpandingItem = function (item, menuItems) { 17942 var submenuItems = item.getSubmenuItems(); 17943 var rest = expand(submenuItems, menuItems); 17944 var newMenus = deepMerge(rest.menus, wrap$1(item.value, rest.items)); 17945 var newExpansions = deepMerge(rest.expansions, wrap$1(item.value, item.value)); 17946 return { 17947 item: item, 17948 menus: newMenus, 17949 expansions: newExpansions 17950 }; 17951 }; 17952 var getFromItem = function (item, menuItems) { 17953 return isExpandingMenuItem(item) ? getFromExpandingItem(item, menuItems) : { 17954 item: item, 17955 menus: {}, 17956 expansions: {} 17957 }; 17958 }; 17959 var generateValueIfRequired = function (item) { 17960 if (isSeparator(item)) { 17961 return item; 17962 } else { 17963 var itemValue = get$1(item, 'value').getOrThunk(function () { 17964 return generate$1('generated-menu-item'); 17965 }); 17966 return deepMerge({ value: itemValue }, item); 17967 } 17968 }; 17969 var expand = function (items, menuItems) { 17970 var realItems = unwrapReferences(isString(items) ? items.split(' ') : items, menuItems); 17971 return foldr(realItems, function (acc, item) { 17972 var itemWithValue = generateValueIfRequired(item); 17973 var newData = getFromItem(itemWithValue, menuItems); 17974 return { 17975 menus: deepMerge(acc.menus, newData.menus), 17976 items: [newData.item].concat(acc.items), 17977 expansions: deepMerge(acc.expansions, newData.expansions) 17978 }; 17979 }, { 17980 menus: {}, 17981 expansions: {}, 17982 items: [] 17983 }); 17984 }; 17985 17986 var build$2 = function (items, itemResponse, backstage, isHorizontalMenu) { 17987 var primary = generate$1('primary-menu'); 17988 var data = expand(items, backstage.shared.providers.menuItems()); 17989 if (data.items.length === 0) { 17990 return Optional.none(); 17991 } 17992 var mainMenu = createPartialMenu(primary, data.items, itemResponse, backstage, isHorizontalMenu); 17993 var submenus = map$2(data.menus, function (menuItems, menuName) { 17994 return createPartialMenu(menuName, menuItems, itemResponse, backstage, false); 17995 }); 17996 var menus = deepMerge(submenus, wrap$1(primary, mainMenu)); 17997 return Optional.from(tieredMenu.tieredData(primary, menus, data.expansions)); 17998 }; 17999 18000 var getMenuButtonApi = function (component) { 18001 return { 18002 isDisabled: function () { 18003 return Disabling.isDisabled(component); 18004 }, 18005 setDisabled: function (state) { 18006 return Disabling.set(component, state); 18007 },
18008 setActive: function (state) { 18009 var elm = component.element; 18010 if (state) { 18011 add$2(elm, 'tox-tbtn--enabled'); 18012 set$1(elm, 'aria-pressed', true); 18013 } else { 18014 remove$4(elm, 'tox-tbtn--enabled'); 18015 remove$1(elm, 'aria-pressed'); 18016 } 18017 }, 18018 isActive: function () { 18019 return has$2(component.element, 'tox-tbtn--enabled'); 18020 } 18021 }; 18022 }; 18023 var renderMenuButton = function (spec, prefix, backstage, role) { 18024 return renderCommonDropdown({ 18025 text: spec.text, 18026 icon: spec.icon, 18027 tooltip: spec.tooltip, 18028 role: role, 18029 fetch: function (_comp, callback) { 18030 spec.fetch(function (items) { 18031 callback(build$2(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false)); 18032 }); 18033 }, 18034 onSetup: spec.onSetup, 18035 getApi: getMenuButtonApi, 18036 columns: 1, 18037 presets: 'normal', 18038 classes: [], 18039 dropdownBehaviours: [Tabstopping.config({})] 18040 }, prefix, backstage.shared); 18041 }; 18042 var getFetch$1 = function (items, getButton, backstage) { 18043 var getMenuItemAction = function (item) { 18044 return function (api) { 18045 var newValue = !api.isActive(); 18046 api.setActive(newValue); 18047 item.storage.set(newValue); 18048 backstage.shared.getSink().each(function (sink) { 18049 getButton().getOpt(sink).each(function (orig) { 18050 focus$1(orig.element); 18051 emitWith(orig, formActionEvent, { 18052 name: item.name, 18053 value: item.storage.get() 18054 }); 18055 }); 18056 }); 18057 }; 18058 }; 18059 var getMenuItemSetup = function (item) { 18060 return function (api) { 18061 api.setActive(item.storage.get()); 18062 }; 18063 }; 18064 return function (success) { 18065 success(map(items, function (item) { 18066 var text = item.text.fold(function () { 18067 return {}; 18068 }, function (text) { 18069 return { text: text }; 18070 }); 18071 return __assign(__assign({ 18072 type: item.type, 18073 active: false 18074 }, text), { 18075 onAction: getMenuItemAction(item), 18076 onSetup: getMenuItemSetup(item) 18077 }); 18078 })); 18079 }; 18080 }; 18081 18082 var renderCommonSpec = function (spec, actionOpt, extraBehaviours, dom, components, providersBackstage) { 18083 if (extraBehaviours === void 0) { 18084 extraBehaviours = []; 18085 } 18086 var action = actionOpt.fold(function () { 18087 return {}; 18088 }, function (action) { 18089 return { action: action }; 18090 }); 18091 var common = __assign({ 18092 buttonBehaviours: derive$1([ 18093 DisablingConfigs.button(function () { 18094 return spec.disabled || providersBackstage.isDisabled(); 18095 }), 18096 receivingConfig(), 18097 Tabstopping.config({}), 18098 config('button press', [ 18099 preventDefault('click'), 18100 preventDefault('mousedown') 18101 ]) 18102 ].concat(extraBehaviours)), 18103 eventOrder: { 18104 click: [ 18105 'button press', 18106 'alloy.base.behaviour' 18107 ], 18108 mousedown: [ 18109 'button press', 18110 'alloy.base.behaviour' 18111 ] 18112 } 18113 }, action); 18114 var domFinal = deepMerge(common, { dom: dom }); 18115 return deepMerge(domFinal, { components: components }); 18116 }; 18117 var renderIconButtonSpec = function (spec, action, providersBackstage, extraBehaviours) { 18118 if (extraBehaviours === void 0) { 18119 extraBehaviours = []; 18120 } 18121 var tooltipAttributes = spec.tooltip.map(function (tooltip) { 18122 return { 18123 'aria-label': providersBackstage.translate(tooltip), 18124 'title': providersBackstage.translate(tooltip) 18125 }; 18126 }).getOr({}); 18127 var dom = { 18128 tag: 'button', 18129 classes: ['tox-tbtn'], 18130 attributes: tooltipAttributes 18131 }; 18132 var icon = spec.icon.map(function (iconName) { 18133 return renderIconFromPack(iconName, providersBackstage.icons); 18134 }); 18135 var components = componentRenderPipeline([icon]); 18136 return renderCommonSpec(spec, action, extraBehaviours, dom, components, providersBackstage); 18137 }; 18138 var renderIconButton = function (spec, action, providersBackstage, extraBehaviours) { 18139 if (extraBehaviours === void 0) { 18140 extraBehaviours = []; 18141 } 18142 var iconButtonSpec = renderIconButtonSpec(spec, Optional.some(action), providersBackstage, extraBehaviours); 18143 return Button.sketch(iconButtonSpec); 18144 }; 18145 var renderButtonSpec = function (spec, action, providersBackstage, extraBehaviours, extraClasse
18145s) { 18146 if (extraBehaviours === void 0) { 18147 extraBehaviours = []; 18148 } 18149 if (extraClasses === void 0) { 18150 extraClasses = []; 18151 } 18152 var translatedText = providersBackstage.translate(spec.text); 18153 var icon = spec.icon ? spec.icon.map(function (iconName) { 18154 return renderIconFromPack(iconName, providersBackstage.icons); 18155 }) : Optional.none(); 18156 var components = icon.isSome() ? componentRenderPipeline([icon]) : []; 18157 var innerHtml = icon.isSome() ? {} : { innerHtml: translatedText }; 18158 var classes = __spreadArrays(!spec.primary && !spec.borderless ? [ 18159 'tox-button', 18160 'tox-button--secondary' 18161 ] : ['tox-button'], icon.isSome() ? ['tox-button--icon'] : [], spec.borderless ? ['tox-button--naked'] : [], extraClasses); 18162 var dom = __assign(__assign({ 18163 tag: 'button', 18164 classes: classes 18165 }, innerHtml), { attributes: { 'title': translatedText } }); 18166 return renderCommonSpec(spec, action, extraBehaviours, dom, components, providersBackstage); 18167 }; 18168 var renderButton = function (spec, action, providersBackstage, extraBehaviours, extraClasses) { 18169 if (extraBehaviours === void 0) { 18170 extraBehaviours = []; 18171 } 18172 if (extraClasses === void 0) { 18173 extraClasses = []; 18174 } 18175 var buttonSpec = renderButtonSpec(spec, Optional.some(action), providersBackstage, extraBehaviours, extraClasses); 18176 return Button.sketch(buttonSpec); 18177 }; 18178 var getAction = function (name, buttonType) { 18179 return function (comp) { 18180 if (buttonType === 'custom') { 18181 emitWith(comp, formActionEvent, { 18182 name: name, 18183 value: {} 18184 }); 18185 } else if (buttonType === 'submit') { 18186 emit(comp, formSubmitEvent); 18187 } else if (buttonType === 'cancel') { 18188 emit(comp, formCancelEvent); 18189 } else { 18190 console.error('Unknown button type: ', buttonType); 18191 } 18192 }; 18193 }; 18194 var isMenuFooterButtonSpec = function (spec, buttonType) { 18195 return buttonType === 'menu'; 18196 }; 18197 var isNormalFooterButtonSpec = function (spec, buttonType) { 18198 return buttonType === 'custom' || buttonType === 'cancel' || buttonType === 'submit'; 18199 }; 18200 var renderFooterButton = function (spec, buttonType, backstage) { 18201 if (isMenuFooterButtonSpec(spec, buttonType)) { 18202 var getButton = function () { 18203 return memButton_1; 18204 }; 18205 var menuButtonSpec = spec; 18206 var fixedSpec = __assign(__assign({}, spec), { 18207 onSetup: function (api) { 18208 api.setDisabled(spec.disabled); 18209 return noop; 18210 }, 18211 fetch: getFetch$1(menuButtonSpec.items, getButton, backstage) 18212 }); 18213 var memButton_1 = record(renderMenuButton(fixedSpec, 'tox-tbtn', backstage, Optional.none())); 18214 return memButton_1.asSpec(); 18215 } else if (isNormalFooterButtonSpec(spec, buttonType)) { 18216 var action = getAction(spec.name, buttonType); 18217 var buttonSpec = __assign(__assign({}, spec), { borderless: false }); 18218 return renderButton(buttonSpec, action, backstage.shared.providers, []); 18219 } else { 18220 console.error('Unknown footer button type: ', buttonType); 18221 } 18222 }; 18223 var renderDialogButton = function (spec, providersBackstage) { 18224 var action = getAction(spec.name, 'custom'); 18225 return renderFormField(Optional.none(), FormField.parts.field(__assign({ factory: Button }, renderButtonSpec(spec, Optional.some(action), providersBackstage, [ 18226 RepresentingConfigs.memory(''), 18227 ComposingConfigs.self() 18228 ])))); 18229 }; 18230 18231 var schema$i = constant([ 18232 defaulted$1('field1Name', 'field1'), 18233 defaulted$1('field2Name', 'field2'), 18234 onStrictHandler('onLockedChange'), 18235 markers(['lockClass']), 18236 defaulted$1('locked', false), 18237 SketchBehaviours.field('coupledFieldBehaviours', [ 18238 Composing, 18239 Representing 18240 ]) 18241 ]); 18242 var getField = function (comp, detail, partName) { 18243 return getPart(comp, detail, partName).bind(Composing.getCurrent); 18244 }; 18245 var coupledPart = function (selfName, otherName) { 18246 return required({ 18247 factory: FormField, 18248 name: selfName, 18249 overrides: function (detail) { 18250 return {
18251 fieldBehaviours: derive$1([config('coupled-input-behaviour', [run(input(), function (me) { 18252 getField(me, detail, otherName).each(function (other) { 18253 getPart(me, detail, 'lock').each(function (lock) { 18254 if (Toggling.isOn(lock)) { 18255 detail.onLockedChange(me, other, lock); 18256 } 18257 }); 18258 }); 18259 })])]) 18260 }; 18261 } 18262 }); 18263 }; 18264 var parts$5 = constant([ 18265 coupledPart('field1', 'field2'), 18266 coupledPart('field2', 'field1'), 18267 required({ 18268 factory: Button, 18269 schema: [strict$1('dom')], 18270 name: 'lock', 18271 overrides: function (detail) { 18272 return { 18273 buttonBehaviours: derive$1([Toggling.config({ 18274 selected: detail.locked, 18275 toggleClass: detail.markers.lockClass, 18276 aria: { mode: 'pressed' } 18277 })]) 18278 }; 18279 } 18280 }) 18281 ]); 18282 18283 var factory$7 = function (detail, components, _spec, _externals) { 18284 return { 18285 uid: detail.uid, 18286 dom: detail.dom, 18287 components: components, 18288 behaviours: SketchBehaviours.augment(detail.coupledFieldBehaviours, [ 18289 Composing.config({ find: Optional.some }), 18290 Representing.config({ 18291 store: { 18292 mode: 'manual', 18293 getValue: function (comp) { 18294 var _a; 18295 var parts = getPartsOrDie(comp, detail, [ 18296 'field1', 18297 'field2' 18298 ]); 18299 return _a = {}, _a[detail.field1Name] = Representing.getValue(parts.field1()), _a[detail.field2Name] = Representing.getValue(parts.field2()), _a; 18300 }, 18301 setValue: function (comp, value) { 18302 var parts = getPartsOrDie(comp, detail, [ 18303 'field1', 18304 'field2' 18305 ]); 18306 if (hasNonNullableKey(value, detail.field1Name)) { 18307 Representing.setValue(parts.field1(), value[detail.field1Name]); 18308 } 18309 if (hasNonNullableKey(value, detail.field2Name)) { 18310 Representing.setValue(parts.field2(), value[detail.field2Name]); 18311 } 18312 } 18313 } 18314 }) 18315 ]), 18316 apis: { 18317 getField1: function (component) { 18318 return getPart(component, detail, 'field1'); 18319 }, 18320 getField2: function (component) { 18321 return getPart(component, detail, 'field2'); 18322 }, 18323 getLock: function (component) { 18324 return getPart(component, detail, 'lock'); 18325 } 18326 } 18327 }; 18328 }; 18329 var FormCoupledInputs = composite$1({ 18330 name: 'FormCoupledInputs', 18331 configFields: schema$i(), 18332 partFields: parts$5(), 18333 factory: factory$7, 18334 apis: { 18335 getField1: function (apis, component) { 18336 return apis.getField1(component); 18337 }, 18338 getField2: function (apis, component) { 18339 return apis.getField2(component); 18340 }, 18341 getLock: function (apis, component) { 18342 return apis.getLock(component); 18343 } 18344 } 18345 }); 18346 18347 var formatSize = function (size) { 18348 var unitDec = { 18349 '': 0, 18350 'px': 0, 18351 'pt': 1, 18352 'mm': 1, 18353 'pc': 2, 18354 'ex': 2, 18355 'em': 2, 18356 'ch': 2, 18357 'rem': 2, 18358 'cm': 3, 18359 'in': 4, 18360 '%': 4 18361 }; 18362 var maxDecimal = function (unit) { 18363 return unit in unitDec ? unitDec[unit] : 1; 18364 }; 18365 var numText = size.value.toFixed(maxDecimal(size.unit)); 18366 if (numText.indexOf('.') !== -1) { 18367 numText = numText.replace(/\.?0*$/, ''); 18368 } 18369 return numText + size.unit; 18370 }; 18371 var parseSize = function (sizeText) { 18372 var numPattern = /^\s*(\d+(?:\.\d+)?)\s*(|cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)\s*$/; 18373 var match = numPattern.exec(sizeText); 18374 if (match !== null) { 18375 var value = parseFloat(match[1]); 18376 var unit = match[2]; 18377 return Result.value({ 18378 value: value, 18379 unit: unit 18380 }); 18381 } else { 18382 return Result.error(sizeText); 18383 } 18384 }; 18385 var convertUnit = function (size, unit) { 18386 var inInch = { 18387 '': 96, 18388 'px': 96, 18389 'pt': 72, 18390 'cm': 2.54, 18391 'pc': 12, 18392 'mm': 25.4, 18393 'in': 1 18394 }; 18395 var supported = function (u) { 18396 return Object.prototype.hasOwnProperty.call(inInch, u); 18397 }; 18398 if (size.unit === unit) { 18399 return Optional.some(size.value); 18400 } else if (supported(size.unit) && supported(unit)) { 18401 if (inInch[size.unit] === inInch[unit]) { 18402 return Optional.some(size.value); 18403 } else { 18404 return Optional.some(size.value / inInch[size.unit] * inInch[unit]); 18405 } 18406 } else { 18407 return Optional.none(); 18408 } 18409 }; 18410 var noSizeConversion = function (_input) { 18411 return Optional.none(); 18412 }; 18413 var ratioSizeConversion = function (scale, unit) { 18414 return function (size) { 18415 return convertUnit(size, unit).map(function (value) { 18416 return { 18417 value: value * scale, 18418 unit: unit 18419 }; 18420 }); 18421 }; 18422 }; 18423 var makeRatioConverter = function (currentFieldText, otherFieldText) { 18424 var cValue = parseSize(currentFieldText).toOptional(); 18425 var oValue = parseSize(otherFieldText).toOptional(); 18426 return lift2(cValue, oValue, function (cSize, oSize) { 18427 return convertUnit(cSize, oSize.unit).map(function (val) { 18428 return oSize.value / val; 18429 }).map(function (r) { 18430 return ratioSizeConversion(r, oSize.unit); 18431 }).getOr(noSizeConversion); 18432 }).getOr(noSizeConversion); 18433 }; 18434 18435 var renderSizeInput = function (spec, providersBackstage) { 18436 var converter = noSizeConversion; 18437 var ratioEvent = generate$1('ratio-event'); 18438 var pLock = FormCoupledInputs.parts.lock({ 18439 dom: { 18440 tag: 'button', 18441 classes: [ 18442 'tox-lock', 18443 'tox-button', 18444 'tox-button--naked', 18445 'tox-button--icon' 18446 ], 18447 attributes: { title: providersBackstage.translate(spec.label.getOr('Constrain proportions')) } 18448 }, 18449 components: [ 18450 { 18451 dom: { 18452 tag: 'span', 18453 classes: [ 18454 'tox-icon', 18455 'tox-lock-icon__lock' 18456 ], 18457 innerHtml: get$e('lock', providersBackstage.icons) 18458 } 18459 }, 18460 { 18461 dom: { 18462 tag: 'span', 18463 classes: [ 18464 'tox-icon', 18465 'tox-lock-icon__unlock' 18466 ], 18467 innerHtml: get$e('unlock', providersBackstage.icons) 18468 } 18469 } 18470 ], 18471 buttonBehaviours: derive$1([ 18472 Disabling.config({ 18473 disabled: function () { 18474 return spec.disabled || providersBackstage.isDisabled(); 18475 } 18476 }), 18477 receivingConfig(), 18478 Tabstopping.config({}) 18479 ]) 18480 }); 18481 var formGroup = function (components) { 18482 return { 18483 dom: { 18484 tag: 'div', 18485 classes: ['tox-form__group'] 18486 }, 18487 components: components 18488 }; 18489 }; 18490 var getFieldPart = function (isField1) { 18491 return FormField.parts.field({ 18492 factory: Input, 18493 inputClasses: ['tox-textfield'], 18494 inputBehaviours: derive$1([ 18495 Disabling.config({ 18496 disabled: function () { 18497 return spec.disabled || providersBackstage.isDisabled(); 18498 } 18499 }), 18500 receivingConfig(), 18501 Tabstopping.config({}), 18502 config('size-input-events', [ 18503 run(focusin(), function (component, _simulatedEvent) { 18504 emitWith(component, ratioEvent, { isField1: isField1 }); 18505 }), 18506 run(change(), function (component, _simulatedEvent) { 18507 emitWith(component, formChangeEvent, { name: spec.name }); 18508 }) 18509 ]) 18510 ]), 18511 selectOnFocus: false 18512 }); 18513 }; 18514 var getLabel = function (label) { 18515 return { 18516 dom: { 18517 tag: 'label', 18518 classes: ['tox-label'], 18519 innerHtml: providersBackstage.translate(label) 18520 } 18521 }; 18522 }; 18523 var widthField = FormCoupledInputs.parts.field1(formGroup([ 18524 FormField.parts.label(getLabel('Width')), 18525 getFieldPart(true) 18526 ])); 18527 var heightField = FormCoupledInputs.parts.field2(formGroup([ 18528 FormField.parts.label(getLabel('Height')), 18529 getFieldPart(false) 18530 ])); 18531 return FormCoupledInputs.sketch({ 18532 dom: { 18533 tag: 'div', 18534 classes: ['tox-form__group'] 18535 }, 18536 components: [{ 18537 dom: { 18538 tag: 'div', 18539 classes: ['tox-form__controls-h-stack'] 18540 }, 18541 components: [ 18542 widthField, 18543 heightField, 18544 formGroup([ 18545 getLabel(' '), 18546 pLock 18547 ]) 18548 ] 18549 }], 18550 field1Name: 'width', 18551 field2Name: 'height', 18552 locked: true, 18553 markers: { lockClass: 'tox-locked' }, 18554 onLockedChange: function (current, other, _lock) { 18555 parseSize(Representing.getValue(current)).each(function (size) { 18556 converter(size).each(function (newSize) { 18557 Representing.setValue(other, formatSize(newSize)); 18558 }); 18559 }); 18560 }, 18561 coupledFieldBehaviours: derive$1([ 18562 Disabling.config({ 18563 disabled: function () { 18564 return spec.disabled || providersBackstage.isDisabled(); 18565 }, 18566 onDisabled: function (comp) { 18567 FormCoupledInputs.getField1(comp).bind(FormField.getField).each(Disabling.disable); 18568 FormCoupledInputs.getField2(comp).bind(FormField.getField).each(Disabling.disable); 18569 FormCoupledInputs.getLock(comp).each(Disabling.disable); 18570 }, 18571 onEnabled: function (comp) { 18572 FormCoupledInputs.getField1(comp).bind(FormField.getField).each(Disabling.enable); 18573 FormCoupledInputs.getField2(comp).bind(FormField.getField).each(Disabling.enable); 18574 FormCoupledInputs.getLock(comp).each(Disabling.enable); 18575 } 18576 }), 18577 receivingConfig(), 18578 config('size-input-events2', [run(ratioEvent, function (component, simulatedEvent) {
18579 var isField1 = simulatedEvent.event.isField1; 18580 var optCurrent = isField1 ? FormCoupledInputs.getField1(component) : FormCoupledInputs.getField2(component); 18581 var optOther = isField1 ? FormCoupledInputs.getField2(component) : FormCoupledInputs.getField1(component); 18582 var value1 = optCurrent.map(Representing.getValue).getOr(''); 18583 var value2 = optOther.map(Representing.getValue).getOr(''); 18584 converter = makeRatioConverter(value1, value2); 18585 })]) 18586 ]) 18587 }); 18588 }; 18589 18590 var undo = constant(generate$1('undo')); 18591 var redo = constant(generate$1('redo')); 18592 var zoom = constant(generate$1('zoom')); 18593 var back = constant(generate$1('back')); 18594 var apply = constant(generate$1('apply')); 18595 var swap = constant(generate$1('swap')); 18596 var transform = constant(generate$1('transform')); 18597 var tempTransform = constant(generate$1('temp-transform')); 18598 var transformApply = constant(generate$1('transform-apply')); 18599 var internal = { 18600 undo: undo, 18601 redo: redo, 18602 zoom: zoom, 18603 back: back, 18604 apply: apply, 18605 swap: swap, 18606 transform: transform, 18607 tempTransform: tempTransform, 18608 transformApply: transformApply 18609 }; 18610 var saveState = constant('save-state'); 18611 var disable$1 = constant('disable'); 18612 var enable$1 = constant('enable'); 18613 var external$2 = { 18614 formActionEvent: formActionEvent, 18615 saveState: saveState, 18616 disable: disable$1, 18617 enable: enable$1 18618 }; 18619 18620 var renderEditPanel = function (imagePanel, providersBackstage) { 18621 var createButton = function (text, action, disabled, primary) { 18622 return record(renderButton({ 18623 name: text, 18624 text: text, 18625 disabled: disabled, 18626 primary: primary, 18627 icon: Optional.none(), 18628 borderless: false 18629 }, action, providersBackstage)); 18630 }; 18631 var createIconButton = function (icon, tooltip, action, disabled) { 18632 return record(renderIconButton({ 18633 name: icon, 18634 icon: Optional.some(icon), 18635 tooltip: Optional.some(tooltip), 18636 disabled: disabled, 18637 primary: false, 18638 borderless: false 18639 }, action, providersBackstage)); 18640 }; 18641 var disableAllComponents = function (comps, eventcomp) { 18642 comps.map(function (mem) { 18643 var component = mem.get(eventcomp); 18644 if (component.hasConfigured(Disabling)) { 18645 Disabling.disable(component); 18646 } 18647 }); 18648 }; 18649 var enableAllComponents = function (comps, eventcomp) { 18650 comps.map(function (mem) { 18651 var component = mem.get(eventcomp); 18652 if (component.hasConfigured(Disabling)) { 18653 Disabling.enable(component); 18654 } 18655 }); 18656 }; 18657 var panelDom = { 18658 tag: 'div', 18659 classes: [ 18660 'tox-image-tools__toolbar', 18661 'tox-image-tools-edit-panel' 18662 ] 18663 }; 18664 var noop$1 = noop; 18665 var emit$1 = function (comp, event, data) { 18666 emitWith(comp, event, data); 18667 }; 18668 var emitDisable = function (component) { 18669 return emit(component, external$2.disable()); 18670 }; 18671 var emitEnable = function (component) { 18672 return emit(component, external$2.enable()); 18673 }; 18674 var emitTransform = function (comp, transform) { 18675 emitDisable(comp); 18676 emit$1(comp, internal.transform(), { transform: transform }); 18677 emitEnable(comp); 18678 }; 18679 var emitTempTransform = function (comp, transform) { 18680 emitDisable(comp); 18681 emit$1(comp, internal.tempTransform(), { transform: transform }); 18682 emitEnable(comp); 18683 }; 18684 var getBackSwap = function (anyInSystem) { 18685 return function () { 18686 memContainer.getOpt(anyInSystem).each(function (container) { 18687 Replacing.set(container, [ButtonPanel]); 18688 }); 18689 }; 18690 }; 18691 var emitTransformApply = function (comp, transform) { 18692 emitDisable(comp); 18693 emit$1(comp, internal.transformApply(), { 18694 transform: transform, 18695 swap: getBackSwap(comp) 18696 }); 18697 emitEnable(comp); 18698 }; 18699 var createBackButton = function () { 18700 return createButton('Back', function (button) { 18701 return emit$1(button, internal.back(), { swap: getBackSwap(button) }); 18702 }, false, false); 18703 }; 18704 var createSpacer = function () { 18705 return record({ 18706 dom: { 18707 tag: 'div', 18708 classes: ['tox-spacer'] 18709 }, 18710 behaviours: derive$1([Disabling.config({})]) 18711 }); 18712 }; 18713 var createApplyButton = function () { 18714 return createButton('Apply', function (button) { 18715 return emit$1(button, internal.apply(), { swap: getBackSwap(button) }); 18716 }, true, true); 18717 }; 18718 var makeCropTransform = function () { 18719 return function (ir) { 18720 var rect = imagePanel.getRect(); 18721 return crop$1(ir, rect.x, rect.y, rect.w, rect.h); 18722 }; 18723 }; 18724 var cropPanelComponents = [ 18725 createBackButton(), 18726 createSpacer(), 18727 createButton('Apply', function (button) { 18728 var transform = makeCropTransform(); 18729 emitTransformApply(button, transform); 18730 imagePanel.hideCrop(); 18731 }, false, true) 18732 ]; 18733 var CropPanel = Container.sketch({ 18734 dom: panelDom, 18735 components: cropPanelComponents.map(function (mem) { 18736 return mem.asSpec(); 18737 }),
18738 containerBehaviours: derive$1([config('image-tools-crop-buttons-events', [ 18739 run(external$2.disable(), function (comp, _se) { 18740 disableAllComponents(cropPanelComponents, comp); 18741 }), 18742 run(external$2.enable(), function (comp, _se) { 18743 enableAllComponents(cropPanelComponents, comp); 18744 }) 18745 ])]) 18746 }); 18747 var memSize = record(renderSizeInput({ 18748 name: 'size', 18749 label: Optional.none(), 18750 constrain: true, 18751 disabled: false 18752 }, providersBackstage)); 18753 var makeResizeTransform = function (width, height) { 18754 return function (ir) { 18755 return resize$2(ir, width, height); 18756 }; 18757 }; 18758 var resizePanelComponents = [ 18759 createBackButton(), 18760 createSpacer(), 18761 memSize, 18762 createSpacer(), 18763 createButton('Apply', function (button) { 18764 memSize.getOpt(button).each(function (sizeInput) { 18765 var value = Representing.getValue(sizeInput); 18766 var width = parseInt(value.width, 10); 18767 var height = parseInt(value.height, 10); 18768 var transform = makeResizeTransform(width, height); 18769 emitTransformApply(button, transform); 18770 }); 18771 }, false, true) 18772 ]; 18773 var ResizePanel = Container.sketch({ 18774 dom: panelDom, 18775 components: resizePanelComponents.map(function (mem) { 18776 return mem.asSpec(); 18777 }), 18778 containerBehaviours: derive$1([config('image-tools-resize-buttons-events', [ 18779 run(external$2.disable(), function (comp, _se) { 18780 disableAllComponents(resizePanelComponents, comp); 18781 }), 18782 run(external$2.enable(), function (comp, _se) { 18783 enableAllComponents(resizePanelComponents, comp); 18784 }) 18785 ])]) 18786 }); 18787 var makeValueTransform = function (transform, value) { 18788 return function (ir) { 18789 return transform(ir, value); 18790 }; 18791 }; 18792 var horizontalFlip = makeValueTransform(flip$1, 'h'); 18793 var verticalFlip = makeValueTransform(flip$1, 'v'); 18794 var counterclockwiseRotate = makeValueTransform(rotate$1, -90); 18795 var clockwiseRotate = makeValueTransform(rotate$1, 90); 18796 var flipRotateOnAction = function (comp, operation) { 18797 emitTempTransform(comp, operation); 18798 }; 18799 var flipRotateComponents = [ 18800 createBackButton(), 18801 createSpacer(), 18802 createIconButton('flip-horizontally', 'Flip horizontally', function (button) { 18803 flipRotateOnAction(button, horizontalFlip); 18804 }, false), 18805 createIconButton('flip-vertically', 'Flip vertically', function (button) { 18806 flipRotateOnAction(button, verticalFlip); 18807 }, false), 18808 createIconButton('rotate-left', 'Rotate counterclockwise', function (button) { 18809 flipRotateOnAction(button, counterclockwiseRotate); 18810 }, false), 18811 createIconButton('rotate-right', 'Rotate clockwise', function (button) { 18812 flipRotateOnAction(button, clockwiseRotate); 18813 }, false), 18814 createSpacer(), 18815 createApplyButton() 18816 ]; 18817 var FlipRotatePanel = Container.sketch({ 18818 dom: panelDom, 18819 components: flipRotateComponents.map(function (mem) { 18820 return mem.asSpec(); 18821 }), 18822 containerBehaviours: derive$1([config('image-tools-fliprotate-buttons-events', [ 18823 run(external$2.disable(), function (comp, _se) { 18824 disableAllComponents(flipRotateComponents, comp); 18825 }), 18826 run(external$2.enable(), function (comp, _se) { 18827 enableAllComponents(flipRotateComponents, comp); 18828 }) 18829 ])]) 18830 }); 18831 var makeSlider = function (label, onChoose, min, value, max) { 18832 var labelPart = Slider.parts.label({ 18833 dom: { 18834 tag: 'label', 18835 classes: ['tox-label'], 18836 innerHtml: providersBackstage.translate(label) 18837 } 18838 }); 18839 var spectrum = Slider.parts.spectrum({ 18840 dom: { 18841 tag: 'div', 18842 classes: ['tox-slider__rail'], 18843 attributes: { role: 'presentation' } 18844 } 18845 }); 18846 var thumb = Slider.parts.thumb({ 18847 dom: { 18848 tag: 'div', 18849 classes: ['tox-slider__handle'], 18850 attributes: { role: 'presentation' } 18851 } 18852 }); 18853 return record(Slider.sketch({ 18854 dom: { 18855 tag: 'div', 18856 classes: ['tox-slider'], 18857 attributes: { role: 'presentation' } 18858 }, 18859 model: { 18860 mode: 'x', 18861 minX: min, 18862 maxX: max, 18863 getInitialValue: constant({ x: value }) 18864 }, 18865 components: [ 18866 labelPart, 18867 spectrum, 18868 thumb 18869 ], 18870 sliderBehaviours: derive$1([Focusing.config({})]), 18871 onChoose: onChoose 18872 })); 18873 }; 18874 var makeVariableSlider = function (label, transform, min, value, max) { 18875 var onChoose = function (slider, _thumb, value) { 18876 var valTransform = makeValueTransform(transform, value.x / 100); 18877 emitTransform(slider, valTransform); 18878 }; 18879 return makeSlider(label, onChoose, min, value, max); 18880 }; 18881 var variableFilterPanelComponents = function (label, transform, min, value, max) { 18882 return [ 18883 createBackButton(), 18884 makeVariableSlider(label, transform, min, value, max), 18885 createApplyButton() 18886 ]; 18887 }; 18888 var createVariableFilterPanel = function (label, transform, min, value, max) { 18889 var filterPanelComponents = variableFilterPanelComponents(label, transform, min, value, max); 18890 return Container.sketch({ 18891 dom: panelDom, 18892 components: filterPanelComponents.map(function (mem) { 18893 return mem.asSpec(); 18894 }),
18895 containerBehaviours: derive$1([config('image-tools-filter-panel-buttons-events', [ 18896 run(external$2.disable(), function (comp, _se) { 18897 disableAllComponents(filterPanelComponents, comp); 18898 }), 18899 run(external$2.enable(), function (comp, _se) { 18900 enableAllComponents(filterPanelComponents, comp); 18901 }) 18902 ])]) 18903 }); 18904 }; 18905 var filterPanelComponents = [ 18906 createBackButton(), 18907 createSpacer(), 18908 createApplyButton() 18909 ]; 18910 var FilterPanel = Container.sketch({ 18911 dom: panelDom, 18912 components: filterPanelComponents.map(function (mem) { 18913 return mem.asSpec(); 18914 }) 18915 }); 18916 var BrightnessPanel = createVariableFilterPanel('Brightness', brightness$1, -100, 0, 100); 18917 var ContrastPanel = createVariableFilterPanel('Contrast', contrast$1, -100, 0, 100); 18918 var GammaPanel = createVariableFilterPanel('Gamma', gamma$1, -100, 0, 100); 18919 var makeColorTransform = function (red, green, blue) { 18920 return function (ir) { 18921 return colorize$1(ir, red, green, blue); 18922 }; 18923 }; 18924 var makeColorSlider = function (label) { 18925 var onChoose = function (slider, _thumb, _value) { 18926 var redOpt = memRed.getOpt(slider); 18927 var blueOpt = memBlue.getOpt(slider); 18928 var greenOpt = memGreen.getOpt(slider); 18929 redOpt.each(function (red) { 18930 blueOpt.each(function (blue) { 18931 greenOpt.each(function (green) { 18932 var r = Representing.getValue(red).x / 100; 18933 var g = Representing.getValue(green).x / 100; 18934 var b = Representing.getValue(blue).x / 100; 18935 var transform = makeColorTransform(r, g, b); 18936 emitTransform(slider, transform); 18937 }); 18938 }); 18939 }); 18940 }; 18941 return makeSlider(label, onChoose, 0, 100, 200); 18942 }; 18943 var memRed = makeColorSlider('R'); 18944 var memGreen = makeColorSlider('G'); 18945 var memBlue = makeColorSlider('B'); 18946 var colorizePanelComponents = [ 18947 createBackButton(), 18948 memRed, 18949 memGreen, 18950 memBlue, 18951 createApplyButton() 18952 ]; 18953 var ColorizePanel = Container.sketch({ 18954 dom: panelDom, 18955 components: colorizePanelComponents.map(function (mem) { 18956 return mem.asSpec(); 18957 }) 18958 }); 18959 var getTransformPanelEvent = function (panel, transform, update) { 18960 return function (button) { 18961 var swap = function () { 18962 memContainer.getOpt(button).each(function (container) { 18963 Replacing.set(container, [panel]); 18964 update(container); 18965 }); 18966 }; 18967 emit$1(button, internal.swap(), { 18968 transform: transform, 18969 swap: swap 18970 }); 18971 }; 18972 }; 18973 var cropPanelUpdate = function (_anyInSystem) { 18974 imagePanel.showCrop(); 18975 }; 18976 var resizePanelUpdate = function (anyInSystem) { 18977 memSize.getOpt(anyInSystem).each(function (sizeInput) { 18978 var measurements = imagePanel.getMeasurements(); 18979 var width = measurements.width; 18980 var height = measurements.height; 18981 Representing.setValue(sizeInput, { 18982 width: width, 18983 height: height 18984 }); 18985 }); 18986 }; 18987 var sharpenTransform = Optional.some(sharpen$1); 18988 var invertTransform = Optional.some(invert$1); 18989 var buttonPanelComponents = [ 18990 createIconButton('crop', 'Crop', getTransformPanelEvent(CropPanel, Optional.none(), cropPanelUpdate), false), 18991 createIconButton('resize', 'Resize', getTransformPanelEvent(ResizePanel, Optional.none(), resizePanelUpdate), false), 18992 createIconButton('orientation', 'Orientation', getTransformPanelEvent(FlipRotatePanel, Optional.none(), noop$1), false), 18993 createIconButton('brightness', 'Brightness', getTransformPanelEvent(BrightnessPanel, Optional.none(), noop$1), false), 18994 createIconButton('sharpen', 'Sharpen', getTransformPanelEvent(FilterPanel, sharpenTransform, noop$1), false), 18995 createIconButton('contrast', 'Contrast', getTransformPanelEvent(ContrastPanel, Optional.none(), noop$1), false), 18996 createIconButton('color-levels', 'Color levels', getTransformPanelEvent(ColorizePanel, Optional.none(), noop$1), false), 18997 createIconButton('gamma', 'Gamma', getTransformPanelEvent(GammaPanel, Optional.none(), noop$1), false), 18998 createIconButton('invert', 'Invert', getTransformPanelEvent(FilterPanel, invertTransform, noop$1), false) 18999 ]; 19000 var ButtonPanel = Container.sketch({ 19001 dom: panelDom, 19002 components: buttonPanelComponents.map(function (mem) { 19003 return mem.asSpec(); 19004 }) 19005 }); 19006 var container = Container.sketch({ 19007 dom: { tag: 'div' }, 19008 components: [ButtonPanel], 19009 containerBehaviours: derive$1([Replacing.config({})]) 19010 }); 19011 var memContainer = record(container); 19012 var getApplyButton = function (anyInSystem) { 19013 return memContainer.getOpt(anyInSystem).map(function (container) { 19014 var panel = container.components()[0]; 19015 return panel.components()[panel.components().length - 1]; 19016 }); 19017 }; 19018 return { 19019 memContainer: memContainer, 19020 getApplyButton: getApplyButton 19021 }; 19022 }; 19023 19024 var global$d = tinymce.util.Tools.resolve('tinymce.geom.Rect'); 19025 19026 var global$e = tinymce.util.Tools.resolve('tinymce.dom.DomQuery'); 19027 19028 var global$f = tinymce.util.Tools.resolve('tinymce.util.Observable'); 19029 19030 var global$g = tinymce.util.Tools.resolve('tinymce.util.VK'); 19031 19032 var getDocumentSize = function (doc) { 19033 var max = Math.max; 19034 var documentElement = doc.documentElement; 19035 var body = doc.body; 19036 var scrollWidth = max(documentElement.scrollWidth, body.scrollWidth); 19037 var clientWidth = max(documentElement.clientWidth, body.clientWidth); 19038 var offsetWidth = max(documentElement.offsetWidth, body.offsetWidth); 19039 var scrollHeight = max(documentElement.scrollHeight, body.scrollHeight); 19040 var clientHeight = max(documentElement.clientHeight, body.clientHeight); 19041 var offsetHeight = max(documentElement.offsetHeight, body.offsetHeight); 19042 return { 19043 width: scrollWidth < offsetWidth ? clientWidth : scrollWidth, 19044 height: scrollHeight < offsetHeight ? clientHeight : scrollHeight 19045 }; 19046 }; 19047 var updateWithTouchData = function (e) { 19048 var keys, i; 19049 if (e.changedTouches) { 19050 keys = 'screenX screenY pageX pageY clientX clientY'.split(' '); 19051 for (i = 0; i < keys.length; i++) { 19052 e[keys[i]] = e.changedTouches[0][keys[i]]; 19053 } 19054 } 19055 }; 19056 function DragHelper (id, settings) { 19057 var $eventOverlay; 19058 var doc = settings.document || document; 19059 var downButton; 19060 var startX, startY; 19061 var handleElement = doc.getElementById(settings.handle || id); 19062 var start = function (e) { 19063 var docSize = getDocumentSize(doc); 19064 var cursor; 19065 updateWithTouchData(e); 19066 e.preventDefault(); 19067 downButton = e.button; 19068 var handleElm = handleElement; 19069 startX = e.screenX; 19070 startY = e.screenY; 19071 if (window.getComputedStyle) { 19072 cursor = window.getComputedStyle(handleElm, null).getPropertyValue('cursor'); 19073 } else { 19074 cursor = handleElm.runtimeStyle.cursor; 19075 } 19076 $eventOverlay = global$e('<div></div>').css({ 19077 position: 'absolute', 19078 top: 0, 19079 left: 0,
19080 width: docSize.width, 19081 height: docSize.height, 19082 zIndex: 2147483647, 19083 opacity: 0.0001, 19084 cursor: cursor 19085 }).appendTo(doc.body); 19086 global$e(doc).on('mousemove touchmove', drag).on('mouseup touchend', stop); 19087 settings.start(e); 19088 }; 19089 var drag = function (e) { 19090 updateWithTouchData(e); 19091 if (e.button !== downButton) { 19092 return stop(e); 19093 } 19094 e.deltaX = e.screenX - startX; 19095 e.deltaY = e.screenY - startY; 19096 e.preventDefault(); 19097 settings.drag(e); 19098 }; 19099 var stop = function (e) { 19100 updateWithTouchData(e); 19101 global$e(doc).off('mousemove touchmove', drag).off('mouseup touchend', stop); 19102 $eventOverlay.remove(); 19103 if (settings.stop) { 19104 settings.stop(e); 19105 } 19106 }; 19107 var destroy = function () { 19108 global$e(handleElement).off(); 19109 }; 19110 global$e(handleElement).on('mousedown touchstart', start); 19111 return { destroy: destroy }; 19112 } 19113 19114 var count = 0; 19115 var create$7 = function (currentRect, viewPortRect, clampRect, containerElm, action) { 19116 var dragHelpers; 19117 var prefix = 'tox-'; 19118 var id = prefix + 'crid-' + count++; 19119 var handles = [ 19120 { 19121 name: 'move', 19122 xMul: 0, 19123 yMul: 0, 19124 deltaX: 1, 19125 deltaY: 1, 19126 deltaW: 0, 19127 deltaH: 0, 19128 label: 'Crop Mask' 19129 }, 19130 { 19131 name: 'nw', 19132 xMul: 0, 19133 yMul: 0, 19134 deltaX: 1, 19135 deltaY: 1, 19136 deltaW: -1, 19137 deltaH: -1, 19138 label: 'Top Left Crop Handle' 19139 }, 19140 { 19141 name: 'ne', 19142 xMul: 1, 19143 yMul: 0, 19144 deltaX: 0, 19145 deltaY: 1, 19146 deltaW: 1, 19147 deltaH: -1, 19148 label: 'Top Right Crop Handle' 19149 }, 19150 { 19151 name: 'sw', 19152 xMul: 0, 19153 yMul: 1, 19154 deltaX: 1, 19155 deltaY: 0, 19156 deltaW: -1, 19157 deltaH: 1, 19158 label: 'Bottom Left Crop Handle' 19159 }, 19160 { 19161 name: 'se', 19162 xMul: 1, 19163 yMul: 1, 19164 deltaX: 0, 19165 deltaY: 0, 19166 deltaW: 1, 19167 deltaH: 1, 19168 label: 'Bottom Right Crop Handle' 19169 } 19170 ]; 19171 var blockers = [ 19172 'top', 19173 'right', 19174 'bottom', 19175 'left' 19176 ]; 19177 var getAbsoluteRect = function (outerRect, relativeRect) { 19178 return { 19179 x: relativeRect.x + outerRect.x, 19180 y: relativeRect.y + outerRect.y, 19181 w: relativeRect.w, 19182 h: relativeRect.h 19183 }; 19184 }; 19185 var getRelativeRect = function (outerRect, innerRect) { 19186 return { 19187 x: innerRect.x - outerRect.x, 19188 y: innerRect.y - outerRect.y, 19189 w: innerRect.w, 19190 h: innerRect.h 19191 }; 19192 }; 19193 var getInnerRect = function () { 19194 return getRelativeRect(clampRect, currentRect); 19195 }; 19196 var moveRect = function (handle, startRect, deltaX, deltaY) { 19197 var x, y, w, h, rect; 19198 x = startRect.x; 19199 y = startRect.y; 19200 w = startRect.w; 19201 h = startRect.h; 19202 x += deltaX * handle.deltaX; 19203 y += deltaY * handle.deltaY; 19204 w += deltaX * handle.deltaW; 19205 h += deltaY * handle.deltaH; 19206 if (w < 20) { 19207 w = 20; 19208 } 19209 if (h < 20) { 19210 h = 20; 19211 } 19212 rect = currentRect = global$d.clamp({ 19213 x: x, 19214 y: y, 19215 w: w, 19216 h: h 19217 }, clampRect, handle.name === 'move'); 19218 rect = getRelativeRect(clampRect, rect); 19219 instance.fire('updateRect', { rect: rect }); 19220 setInnerRect(rect); 19221 }; 19222 var render = function () { 19223 var createDragHelper = function (handle) { 19224 var startRect; 19225 return DragHelper(id, { 19226 document: containerElm.ownerDocument, 19227 handle: id + '-' + handle.name, 19228 start: function () { 19229 startRect = currentRect; 19230 }, 19231 drag: function (e) { 19232 moveRect(handle, startRect, e.deltaX, e.deltaY); 19233 } 19234 }); 19235 }; 19236 global$e('<div id="' + id + '" class="' + prefix + 'croprect-container"' + ' role="grid" aria-dropeffect="execute">').appendTo(containerElm); 19237 global$c.each(blockers, function (blocker) { 19238 global$e('#' + id, containerElm).append('<div id="' + id + '-' + blocker + '"class="' + prefix + 'croprect-block" style="display: none" data-mce-bogus="all">'); 19239 }); 19240 global$c.each(handles, function (handle) { 19241 global$e('#' + id, containerElm).append('<div id="' + id + '-' + handle.name + '" class="' + prefix + 'croprect-handle ' + prefix + 'croprect-handle-' + handle.name + '"' + 'style="display: none" data-mce-bogus="all" role="gridcell" tabindex="-1"' + ' aria-label="' + handle.label + '" aria-grabbed="false" title="' + handle.label + '">'); 19242 }); 19243 dragHelpers = global$c.map(handles, createDragHelper); 19244 repaint(currentRect); 19245 global$e(containerElm).on('focusin focusout', function (e) { 19246 global$e(e.target).attr('aria-grabbed', e.type === 'focus' ? 'true' : 'false'); 19247 }); 19248 global$e(containerElm).on('keydown', function (e) { 19249 var activeHandle; 19250 global$c.each(handles, function (handle) { 19251 if (e.target.id === id + '-' + handle.name) { 19252 activeHandle = handle; 19253 return false;
19254 } 19255 }); 19256 var moveAndBlock = function (evt, handle, startRect, deltaX, deltaY) { 19257 evt.stopPropagation(); 19258 evt.preventDefault(); 19259 moveRect(activeHandle, startRect, deltaX, deltaY); 19260 }; 19261 switch (e.keyCode) { 19262 case global$g.LEFT: 19263 moveAndBlock(e, activeHandle, currentRect, -10, 0); 19264 break; 19265 case global$g.RIGHT: 19266 moveAndBlock(e, activeHandle, currentRect, 10, 0); 19267 break; 19268 case global$g.UP: 19269 moveAndBlock(e, activeHandle, currentRect, 0, -10); 19270 break; 19271 case global$g.DOWN: 19272 moveAndBlock(e, activeHandle, currentRect, 0, 10); 19273 break; 19274 case global$g.ENTER: 19275 case global$g.SPACEBAR: 19276 e.preventDefault(); 19277 action(); 19278 break; 19279 } 19280 }); 19281 }; 19282 var toggleVisibility = function (state) { 19283 var selectors = global$c.map(handles, function (handle) { 19284 return '#' + id + '-' + handle.name; 19285 }).concat(global$c.map(blockers, function (blocker) { 19286 return '#' + id + '-' + blocker; 19287 })).join(','); 19288 if (state) { 19289 global$e(selectors, containerElm).show(); 19290 } else { 19291 global$e(selectors, containerElm).hide(); 19292 } 19293 }; 19294 var repaint = function (rect) { 19295 var updateElementRect = function (name, rect) { 19296 if (rect.h < 0) { 19297 rect.h = 0; 19298 } 19299 if (rect.w < 0) { 19300 rect.w = 0; 19301 } 19302 global$e('#' + id + '-' + name, containerElm).css({ 19303 left: rect.x, 19304 top: rect.y, 19305 width: rect.w, 19306 height: rect.h 19307 }); 19308 }; 19309 global$c.each(handles, function (handle) { 19310 global$e('#' + id + '-' + handle.name, containerElm).css({ 19311 left: rect.w * handle.xMul + rect.x, 19312 top: rect.h * handle.yMul + rect.y 19313 }); 19314 }); 19315 updateElementRect('top', { 19316 x: viewPortRect.x, 19317 y: viewPortRect.y, 19318 w: viewPortRect.w, 19319 h: rect.y - viewPortRect.y 19320 }); 19321 updateElementRect('right', { 19322 x: rect.x + rect.w, 19323 y: rect.y, 19324 w: viewPortRect.w - rect.x - rect.w + viewPortRect.x, 19325 h: rect.h 19326 }); 19327 updateElementRect('bottom', { 19328 x: viewPortRect.x, 19329 y: rect.y + rect.h, 19330 w: viewPortRect.w, 19331 h: viewPortRect.h - rect.y - rect.h + viewPortRect.y 19332 }); 19333 updateElementRect('left', { 19334 x: viewPortRect.x, 19335 y: rect.y, 19336 w: rect.x - viewPortRect.x, 19337 h: rect.h 19338 }); 19339 updateElementRect('move', rect); 19340 }; 19341 var setRect = function (rect) { 19342 currentRect = rect; 19343 repaint(currentRect); 19344 }; 19345 var setViewPortRect = function (rect) { 19346 viewPortRect = rect; 19347 repaint(currentRect); 19348 }; 19349 var setInnerRect = function (rect) { 19350 setRect(getAbsoluteRect(clampRect, rect)); 19351 }; 19352 var setClampRect = function (rect) { 19353 clampRect = rect; 19354 repaint(currentRect); 19355 }; 19356 var destroy = function () { 19357 global$c.each(dragHelpers, function (helper) { 19358 helper.destroy(); 19359 }); 19360 dragHelpers = []; 19361 }; 19362 render(); 19363 var instance = global$c.extend({ 19364 toggleVisibility: toggleVisibility, 19365 setClampRect: setClampRect, 19366 setRect: setRect, 19367 getInnerRect: getInnerRect, 19368 setInnerRect: setInnerRect, 19369 setViewPortRect: setViewPortRect, 19370 destroy: destroy 19371 }, global$f); 19372 return instance; 19373 }; 19374 var CropRect = { create: create$7 }; 19375 19376 var loadImage = function (image) { 19377 return new global$4(function (resolve) { 19378 var loaded = function () { 19379 image.removeEventListener('load', loaded); 19380 resolve(image); 19381 }; 19382 if (image.complete) { 19383 resolve(image); 19384 } else { 19385 image.addEventListener('load', loaded); 19386 } 19387 }); 19388 }; 19389 var renderImagePanel = function (initialUrl) { 19390 var memBg = record({ 19391 dom: { 19392 tag: 'div', 19393 classes: ['tox-image-tools__image-bg'], 19394 attributes: { role: 'presentation' } 19395 } 19396 }); 19397 var zoomState = Cell(1); 19398 var cropRect = Cell(Optional.none()); 19399 var rectState = Cell({ 19400 x: 0, 19401 y: 0, 19402 w: 1, 19403 h: 1 19404 }); 19405 var viewRectState = Cell({ 19406 x: 0, 19407 y: 0, 19408 w: 1, 19409 h: 1 19410 }); 19411 var repaintImg = function (anyInSystem, img) { 19412 memContainer.getOpt(anyInSystem).each(function (panel) { 19413 var zoom = zoomState.get(); 19414 var panelW = get$8(panel.element); 19415 var panelH = get$7(panel.element);
19416 var width = img.dom.naturalWidth * zoom; 19417 var height = img.dom.naturalHeight * zoom; 19418 var left = Math.max(0, panelW / 2 - width / 2); 19419 var top = Math.max(0, panelH / 2 - height / 2); 19420 var css = { 19421 left: left.toString() + 'px', 19422 top: top.toString() + 'px', 19423 width: width.toString() + 'px', 19424 height: height.toString() + 'px', 19425 position: 'absolute' 19426 }; 19427 setAll$1(img, css); 19428 memBg.getOpt(panel).each(function (bg) { 19429 setAll$1(bg.element, css); 19430 }); 19431 cropRect.get().each(function (cRect) { 19432 var rect = rectState.get(); 19433 cRect.setRect({ 19434 x: rect.x * zoom + left, 19435 y: rect.y * zoom + top, 19436 w: rect.w * zoom, 19437 h: rect.h * zoom 19438 }); 19439 cRect.setClampRect({ 19440 x: left, 19441 y: top, 19442 w: width, 19443 h: height 19444 }); 19445 cRect.setViewPortRect({ 19446 x: 0, 19447 y: 0, 19448 w: panelW, 19449 h: panelH 19450 }); 19451 }); 19452 }); 19453 }; 19454 var zoomFit = function (anyInSystem, img) { 19455 memContainer.getOpt(anyInSystem).each(function (panel) { 19456 var panelW = get$8(panel.element); 19457 var panelH = get$7(panel.element); 19458 var width = img.dom.naturalWidth; 19459 var height = img.dom.naturalHeight; 19460 var zoom = Math.min(panelW / width, panelH / height); 19461 if (zoom >= 1) { 19462 zoomState.set(1); 19463 } else { 19464 zoomState.set(zoom); 19465 } 19466 }); 19467 }; 19468 var updateSrc = function (anyInSystem, url) { 19469 var img = SugarElement.fromTag('img'); 19470 set$1(img, 'src', url); 19471 return loadImage(img.dom).then(function () { 19472 return memContainer.getOpt(anyInSystem).map(function (panel) { 19473 var aImg = external({ element: img }); 19474 Replacing.replaceAt(panel, 1, Optional.some(aImg)); 19475 var lastViewRect = viewRectState.get(); 19476 var viewRect = { 19477 x: 0, 19478 y: 0, 19479 w: img.dom.naturalWidth, 19480 h: img.dom.naturalHeight 19481 }; 19482 viewRectState.set(viewRect); 19483 var rect = global$d.inflate(viewRect, -20, -20); 19484 rectState.set(rect); 19485 if (lastViewRect.w !== viewRect.w || lastViewRect.h !== viewRect.h) { 19486 zoomFit(panel, img); 19487 } 19488 repaintImg(panel, img); 19489 return img; 19490 }); 19491 }); 19492 }; 19493 var zoom = function (anyInSystem, direction) { 19494 var currentZoom = zoomState.get(); 19495 var newZoom = direction > 0 ? Math.min(2, currentZoom + 0.1) : Math.max(0.1, currentZoom - 0.1); 19496 zoomState.set(newZoom); 19497 memContainer.getOpt(anyInSystem).each(function (panel) { 19498 var img = panel.components()[1].element; 19499 repaintImg(panel, img); 19500 }); 19501 }; 19502 var showCrop = function () { 19503 cropRect.get().each(function (cRect) { 19504 cRect.toggleVisibility(true); 19505 }); 19506 }; 19507 var hideCrop = function () { 19508 cropRect.get().each(function (cRect) { 19509 cRect.toggleVisibility(false); 19510 }); 19511 }; 19512 var getRect = function () { 19513 return rectState.get(); 19514 }; 19515 var container = Container.sketch({ 19516 dom: { 19517 tag: 'div', 19518 classes: ['tox-image-tools__image'] 19519 }, 19520 components: [ 19521 memBg.asSpec(), 19522 { 19523 dom: { 19524 tag: 'img', 19525 attributes: { src: initialUrl } 19526 } 19527 }, 19528 { 19529 dom: { tag: 'div' }, 19530 behaviours: derive$1([config('image-panel-crop-events', [runOnAttached(function (comp) { 19531 memContainer.getOpt(comp).each(function (container) { 19532 var el = container.element.dom; 19533 var cRect = CropRect.create({ 19534 x: 10, 19535 y: 10, 19536 w: 100, 19537 h: 100 19538 }, { 19539 x: 0, 19540 y: 0, 19541 w: 200, 19542 h: 200 19543 }, { 19544 x: 0, 19545 y: 0, 19546 w: 200, 19547 h: 200 19548 }, el, noop); 19549 cRect.toggleVisibility(false); 19550 cRect.on('updateRect', function (e) { 19551 var rect = e.rect; 19552 var zoom = zoomState.get(); 19553 var newRect = { 19554 x: Math.round(rect.x / zoom), 19555 y: Math.round(rect.y / zoom), 19556 w: Math.round(rect.w / zoom), 19557 h: Math.round(rect.h / zoom) 19558 }; 19559 rectState.set(newRect); 19560 }); 19561 cropRect.set(Optional.some(cRect)); 19562 }); 19563 })])]) 19564 } 19565 ], 19566 containerBehaviours: derive$1([ 19567 Replacing.config({}), 19568 config('image-panel-events', [runOnAttached(function (comp) { 19569 updateSrc(comp, initialUrl); 19570 })]) 19571 ]) 19572 }); 19573 var memContainer = record(container); 19574 var getMeasurements = function () { 19575 var viewRect = viewRectState.get(); 19576 return { 19577 width: viewRect.w, 19578 height: viewRect.h 19579 }; 19580 }; 19581 return { 19582 memContainer: memContainer, 19583 updateSrc: updateSrc, 19584 zoom: zoom, 19585 showCrop: showCrop, 19586 hideCrop: hideCrop, 19587 getRect: getRect, 19588 getMeasurements: getMeasurements 19589 }; 19590 }; 19591 19592 var createButton = function (innerHtml, icon, disabled, action, providersBackstage) { 19593 return renderIconButton({ 19594 name: innerHtml, 19595 icon: Optional.some(icon), 19596 disabled: disabled, 19597 tooltip: Optional.some(innerHtml), 19598 primary: false, 19599 borderless: false 19600 }, action, providersBackstage); 19601 }; 19602 var setButtonEnabled = function (button, enabled) { 19603 if (enabled) { 19604 Disabling.enable(button); 19605 } else { 19606 Disabling.disable(button); 19607 } 19608 }; 19609 var renderSideBar = function (providersBackstage) { 19610 var updateButtonUndoStates = function (anyInSystem, undoEnabled, redoEnabled) { 19611 memUndo.getOpt(anyInSystem).each(function (undo) { 19612 setButtonEnabled(undo, undoEnabled); 19613 }); 19614 memRedo.getOpt(anyInSystem).each(function (redo) { 19615 setButtonEnabled(redo, redoEnabled); 19616 }); 19617 }; 19618 var memUndo = record(createButton('Undo', 'undo', true, function (button) { 19619 emitWith(button, internal.undo(), { direction: 1 }); 19620 }, providersBackstage)); 19621 var memRedo = record(createButton('Redo', 'redo', true, function (button) { 19622 emitWith(button, internal.redo(), { direction: 1 }); 19623 }, providersBackstage)); 19624 var container = Container.sketch({ 19625 dom: { 19626 tag: 'div', 19627 classes: [ 19628 'tox-image-tools__toolbar', 19629 'tox-image-tools__sidebar' 19630 ] 19631 }, 19632 components: [ 19633 memUndo.asSpec(), 19634 memRedo.asSpec(), 19635 createButton('Zoom in', 'zoom-in', false, function (button) { 19636 emitWith(button, internal.zoom(), { direction: 1 }); 19637 }, providersBackstage), 19638 createButton('Zoom out', 'zoom-out', false, function (button) { 19639 emitWith(button, internal.zoom(), { direction: -1 }); 19640 }, providersBackstage) 19641 ] 19642 }); 19643 return { 19644 container: container, 19645 updateButtonUndoStates: updateButtonUndoStates 19646 }; 19647 }; 19648 19649 function UndoStack () { 19650 var data = []; 19651 var index = -1; 19652 var add = function (state) { 19653 var removed = data.splice(++index); 19654 data.push(state); 19655 return { 19656 state: state, 19657 removed: removed 19658 }; 19659 };
19660 var undo = function () { 19661 if (canUndo()) { 19662 return data[--index]; 19663 } 19664 }; 19665 var redo = function () { 19666 if (canRedo()) { 19667 return data[++index]; 19668 } 19669 }; 19670 var canUndo = function () { 19671 return index > 0; 19672 }; 19673 var canRedo = function () { 19674 return index !== -1 && index < data.length - 1; 19675 }; 19676 return { 19677 data: data, 19678 add: add, 19679 undo: undo, 19680 redo: redo, 19681 canUndo: canUndo, 19682 canRedo: canRedo 19683 }; 19684 } 19685 19686 var makeState = function (initialState) { 19687 var blobState = Cell(initialState); 19688 var tempState = Cell(Optional.none()); 19689 var undoStack = UndoStack(); 19690 undoStack.add(initialState); 19691 var getBlobState = function () { 19692 return blobState.get(); 19693 }; 19694 var setBlobState = function (state) { 19695 blobState.set(state); 19696 }; 19697 var getTempState = function () { 19698 return tempState.get().fold(function () { 19699 return blobState.get(); 19700 }, function (temp) { 19701 return temp; 19702 }); 19703 }; 19704 var updateTempState = function (blob) { 19705 var newTempState = createState(blob); 19706 destroyTempState(); 19707 tempState.set(Optional.some(newTempState)); 19708 return newTempState.url; 19709 }; 19710 var createState = function (blob) { 19711 return { 19712 blob: blob, 19713 url: URL.createObjectURL(blob) 19714 }; 19715 }; 19716 var destroyState = function (state) { 19717 URL.revokeObjectURL(state.url); 19718 }; 19719 var destroyStates = function (states) { 19720 global$c.each(states, destroyState); 19721 }; 19722 var destroyTempState = function () { 19723 tempState.get().each(destroyState); 19724 tempState.set(Optional.none()); 19725 }; 19726 var addBlobState = function (blob) { 19727 var newState = createState(blob); 19728 setBlobState(newState); 19729 var removed = undoStack.add(newState).removed; 19730 destroyStates(removed); 19731 return newState.url; 19732 }; 19733 var addTempState = function (blob) { 19734 var newState = createState(blob); 19735 tempState.set(Optional.some(newState)); 19736 return newState.url; 19737 }; 19738 var applyTempState = function (postApply) { 19739 return tempState.get().fold(noop, function (temp) { 19740 addBlobState(temp.blob); 19741 postApply(); 19742 }); 19743 }; 19744 var undo = function () { 19745 var currentState = undoStack.undo(); 19746 setBlobState(currentState); 19747 return currentState.url; 19748 }; 19749 var redo = function () { 19750 var currentState = undoStack.redo(); 19751 setBlobState(currentState); 19752 return currentState.url; 19753 }; 19754 var getHistoryStates = function () { 19755 var undoEnabled = undoStack.canUndo(); 19756 var redoEnabled = undoStack.canRedo(); 19757 return { 19758 undoEnabled: undoEnabled, 19759 redoEnabled: redoEnabled 19760 }; 19761 }; 19762 return { 19763 getBlobState: getBlobState, 19764 setBlobState: setBlobState, 19765 addBlobState: addBlobState, 19766 getTempState: getTempState, 19767 updateTempState: updateTempState, 19768 addTempState: addTempState, 19769 applyTempState: applyTempState, 19770 destroyTempState: destroyTempState, 19771 undo: undo, 19772 redo: redo, 19773 getHistoryStates: getHistoryStates 19774 }; 19775 }; 19776 19777 var renderImageTools = function (detail, providersBackstage) { 19778 var state = makeState(detail.currentState); 19779 var zoom = function (anyInSystem, simulatedEvent) { 19780 var direction = simulatedEvent.event.direction; 19781 imagePanel.zoom(anyInSystem, direction); 19782 }; 19783 var updateButtonUndoStates = function (anyInSystem) { 19784 var historyStates = state.getHistoryStates(); 19785 sideBar.updateButtonUndoStates(anyInSystem, historyStates.undoEnabled, historyStates.redoEnabled); 19786 emitWith(anyInSystem, external$2.formActionEvent, { 19787 name: external$2.saveState(), 19788 value: historyStates.undoEnabled 19789 }); 19790 }; 19791 var disableUndoRedo = function (anyInSystem) { 19792 sideBar.updateButtonUndoStates(anyInSystem, false, false); 19793 };
19794 var undo = function (anyInSystem, _simulatedEvent) { 19795 var url = state.undo(); 19796 updateSrc(anyInSystem, url).then(function (_oImg) { 19797 unblock(anyInSystem); 19798 updateButtonUndoStates(anyInSystem); 19799 }); 19800 }; 19801 var redo = function (anyInSystem, _simulatedEvent) { 19802 var url = state.redo(); 19803 updateSrc(anyInSystem, url).then(function (_oImg) { 19804 unblock(anyInSystem); 19805 updateButtonUndoStates(anyInSystem); 19806 }); 19807 }; 19808 var imageResultToBlob = function (ir) { 19809 return ir.toBlob(); 19810 }; 19811 var block = function (anyInSystem) { 19812 emitWith(anyInSystem, external$2.formActionEvent, { 19813 name: external$2.disable(), 19814 value: {} 19815 }); 19816 }; 19817 var unblock = function (anyInSystem) { 19818 editPanel.getApplyButton(anyInSystem).each(function (applyButton) { 19819 Disabling.enable(applyButton); 19820 }); 19821 emitWith(anyInSystem, external$2.formActionEvent, { 19822 name: external$2.enable(), 19823 value: {} 19824 }); 19825 }; 19826 var updateSrc = function (anyInSystem, src) { 19827 block(anyInSystem); 19828 return imagePanel.updateSrc(anyInSystem, src); 19829 }; 19830 var blobManipulate = function (anyInSystem, blob, filter, action, swap) { 19831 block(anyInSystem); 19832 return blobToImageResult(blob).then(filter).then(imageResultToBlob).then(action).then(function (url) { 19833 return updateSrc(anyInSystem, url).then(function (oImg) { 19834 updateButtonUndoStates(anyInSystem); 19835 swap(); 19836 unblock(anyInSystem); 19837 return oImg; 19838 }); 19839 }).catch(function (err) { 19840 console.log(err); 19841 unblock(anyInSystem); 19842 return err; 19843 }); 19844 }; 19845 var manipulate = function (anyInSystem, filter, swap) { 19846 var blob = state.getBlobState().blob; 19847 var action = function (blob) { 19848 return state.updateTempState(blob); 19849 }; 19850 blobManipulate(anyInSystem, blob, filter, action, swap); 19851 }; 19852 var tempManipulate = function (anyInSystem, filter) { 19853 var blob = state.getTempState().blob; 19854 var action = function (blob) { 19855 return state.addTempState(blob); 19856 }; 19857 blobManipulate(anyInSystem, blob, filter, action, noop); 19858 }; 19859 var manipulateApply = function (anyInSystem, filter, swap) { 19860 var blob = state.getBlobState().blob; 19861 var action = function (blob) { 19862 var url = state.addBlobState(blob); 19863 destroyTempState(anyInSystem); 19864 return url; 19865 }; 19866 blobManipulate(anyInSystem, blob, filter, action, swap); 19867 }; 19868 var apply = function (anyInSystem, simulatedEvent) { 19869 var postApply = function () { 19870 destroyTempState(anyInSystem); 19871 var swap = simulatedEvent.event.swap; 19872 swap(); 19873 }; 19874 state.applyTempState(postApply); 19875 }; 19876 var destroyTempState = function (anyInSystem) { 19877 var currentUrl = state.getBlobState().url; 19878 state.destroyTempState(); 19879 updateButtonUndoStates(anyInSystem); 19880 return currentUrl; 19881 }; 19882 var cancel = function (anyInSystem) { 19883 var currentUrl = destroyTempState(anyInSystem); 19884 updateSrc(anyInSystem, currentUrl).then(function (_oImg) { 19885 unblock(anyInSystem); 19886 }); 19887 }; 19888 var back = function (anyInSystem, simulatedEvent) { 19889 cancel(anyInSystem); 19890 var swap = simulatedEvent.event.swap; 19891 swap(); 19892 imagePanel.hideCrop(); 19893 }; 19894 var transform = function (anyInSystem, simulatedEvent) { 19895 return manipulate(anyInSystem, simulatedEvent.event.transform, noop); 19896 }; 19897 var tempTransform = function (anyInSystem, simulatedEvent) { 19898 return tempManipulate(anyInSystem, simulatedEvent.event.transform); 19899 }; 19900 var transformApply = function (anyInSystem, simulatedEvent) { 19901 return manipulateApply(anyInSystem, simulatedEvent.event.transform, simulatedEvent.event.swap); 19902 }; 19903 var imagePanel = renderImagePanel(detail.currentState.url); 19904 var sideBar = renderSideBar(providersBackstage); 19905 var editPanel = renderEditPanel(imagePanel, providersBackstage); 19906 var swap = function (anyInSystem, simulatedEvent) { 19907 disableUndoRedo(anyInSystem); 19908 var transform = simulatedEvent.event.transform; 19909 var swap = simulatedEvent.event.swap; 19910 transform.fold(function () { 19911 swap(); 19912 }, function (transform) { 19913 manipulate(anyInSystem, transform, swap); 19914 }); 19915 }; 19916 return { 19917 dom: { 19918 tag: 'div', 19919 attributes: { role: 'presentation' } 19920 }, 19921 components: [ 19922 editPanel.memContainer.asSpec(), 19923 imagePanel.memContainer.asSpec(), 19924 sideBar.container 19925 ], 19926 behaviours: derive$1([ 19927 Representing.config({ 19928 store: { 19929 mode: 'manual', 19930 getValue: function () { 19931 return state.getBlobState(); 19932 } 19933 } 19934 }), 19935 config('image-tools-events', [ 19936 run(internal.undo(), undo), 19937 run(internal.redo(), redo), 19938 run(internal.zoom(), zoom), 19939 run(internal.back(), back), 19940 run(internal.apply(), apply), 19941 run(internal.transform(), transform), 19942 run(internal.tempTransform(), tempTransform), 19943 run(internal.transformApply(), transformApply), 19944 run(internal.swap(), swap) 19945 ]), 19946 ComposingConfigs.self() 19947 ]) 19948 }; 19949 }; 19950 19951 var renderLabel$2 = function (spec, backstageShared) { 19952 var label = { 19953 dom: { 19954 tag: 'label', 19955 innerHtml: backstageShared.providers.translate(spec.label), 19956 classes: ['tox-label'] 19957 } 19958 }; 19959 var comps = map(spec.items, backstageShared.interpreter); 19960 return { 19961 dom: { 19962 tag: 'div', 19963 classes: ['tox-form__group'] 19964 }, 19965 components: [label].concat(comps), 19966 behaviours: derive$1([ 19967 ComposingConfigs.self(), 19968 Replacing.config({}), 19969 RepresentingConfigs.domHtml(Optional.none()), 19970 Keying.config({ mode: 'acyclic' }) 19971 ]) 19972 }; 19973 }; 19974 19975 var isSingleListItem = function (item) { 19976 return !has(item, 'items'); 19977 }; 19978 var dataAttribute = 'data-value'; 19979 var fetchItems = function (dropdownComp, name, items, selectedValue) { 19980 return map(items, function (item) { 19981 if (!isSingleListItem(item)) { 19982 return { 19983 type: 'nestedmenuitem', 19984 text: item.text, 19985 getSubmenuItems: function () { 19986 return fetchItems(dropdownComp, name, item.items, selectedValue); 19987 } 19988 }; 19989 } else { 19990 return { 19991 type: 'togglemenuitem', 19992 text: item.text, 19993 value: item.value, 19994 active: item.value === selectedValue, 19995 onAction: function () { 19996 Representing.setValue(dropdownComp, item.value); 19997 emitWith(dropdownComp, formChangeEvent, { name: name }); 19998 Focusing.focus(dropdownComp); 19999 } 20000 }; 20001 } 20002 }); 20003 }; 20004 var findItemByValue = function (items, value) { 20005 return findMap(items, function (item) { 20006 if (!isSingleListItem(item)) { 20007 return findItemByValue(item.items, value); 20008 } else { 20009 return someIf(item.value === value, item); 20010 } 20011 }); 20012 }; 20013 var renderListBox = function (spec, backstage) { 20014 var providersBackstage = backstage.shared.providers; 20015 var initialItem = head(spec.items).filter(isSingleListItem); 20016 var pLabel = spec.label.map(function (label) { 20017 return renderLabel(label, providersBackstage); 20018 }); 20019 var pField = FormField.parts.field({ 20020 dom: {}, 20021 factory: { 20022 sketch: function (sketchSpec) { 20023 return renderCommonDropdown({ 20024 uid: sketchSpec.uid, 20025 text: initialItem.map(function (item) { 20026 return item.text; 20027 }), 20028 icon: Optional.none(), 20029 tooltip: spec.label, 20030 role: Optional.none(), 20031 fetch: function (comp, callback) { 20032 var items = fetchItems(comp, spec.name, spec.items, Representing.getValue(comp)); 20033 callback(build$2(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false)); 20034 }, 20035 onSetup: constant(noop), 20036 getApi: constant({}), 20037 columns: 1, 20038 presets: 'normal', 20039 classes: [], 20040 dropdownBehaviours: [ 20041 Tabstopping.config({}), 20042 Representing.config({ 20043 store: { 20044 mode: 'manual', 20045 initialValue: initialItem.map(function (item) { 20046 return item.value; 20047 }).getOr(''), 20048 getValue: function (comp) {
20049 return get$3(comp.element, dataAttribute); 20050 }, 20051 setValue: function (comp, data) { 20052 findItemByValue(spec.items, data).each(function (item) { 20053 set$1(comp.element, dataAttribute, item.value); 20054 emitWith(comp, updateMenuText, { text: item.text }); 20055 }); 20056 } 20057 } 20058 }) 20059 ] 20060 }, 'tox-listbox', backstage.shared); 20061 } 20062 } 20063 }); 20064 var listBoxWrap = { 20065 dom: { 20066 tag: 'div', 20067 classes: ['tox-listboxfield'] 20068 }, 20069 components: [pField] 20070 }; 20071 return FormField.sketch({ 20072 dom: { 20073 tag: 'div', 20074 classes: ['tox-form__group'] 20075 }, 20076 components: flatten([ 20077 pLabel.toArray(), 20078 [listBoxWrap] 20079 ]), 20080 fieldBehaviours: derive$1([Disabling.config({ 20081 disabled: constant(spec.disabled), 20082 onDisabled: function (comp) { 20083 FormField.getField(comp).each(Disabling.disable); 20084 }, 20085 onEnabled: function (comp) { 20086 FormField.getField(comp).each(Disabling.enable); 20087 } 20088 })]) 20089 }); 20090 }; 20091 20092 var renderPanel = function (spec, backstage) { 20093 return { 20094 dom: { 20095 tag: 'div', 20096 classes: spec.classes 20097 }, 20098 components: map(spec.items, backstage.shared.interpreter) 20099 }; 20100 }; 20101 20102 var factory$8 = function (detail, _spec) { 20103 var options = map(detail.options, function (option) { 20104 return { 20105 dom: { 20106 tag: 'option', 20107 value: option.value, 20108 innerHtml: option.text 20109 } 20110 }; 20111 }); 20112 var initialValues = detail.data.map(function (v) { 20113 return wrap$1('initialValue', v); 20114 }).getOr({}); 20115 return { 20116 uid: detail.uid, 20117 dom: { 20118 tag: 'select', 20119 classes: detail.selectClasses, 20120 attributes: detail.selectAttributes 20121 }, 20122 components: options, 20123 behaviours: augment(detail.selectBehaviours, [ 20124 Focusing.config({}), 20125 Representing.config({ 20126 store: __assign({ 20127 mode: 'manual', 20128 getValue: function (select) { 20129 return get$6(select.element); 20130 }, 20131 setValue: function (select, newValue) { 20132 var found = find(detail.options, function (opt) { 20133 return opt.value === newValue; 20134 }); 20135 if (found.isSome()) { 20136 set$3(select.element, newValue); 20137 } 20138 } 20139 }, initialValues) 20140 }) 20141 ]) 20142 }; 20143 }; 20144 var HtmlSelect = single$2({ 20145 name: 'HtmlSelect', 20146 configFields: [ 20147 strict$1('options'), 20148 field$1('selectBehaviours', [ 20149 Focusing, 20150 Representing 20151 ]), 20152 defaulted$1('selectClasses', []), 20153 defaulted$1('selectAttributes', {}), 20154 option('data') 20155 ], 20156 factory: factory$8 20157 }); 20158 20159 var renderSelectBox = function (spec, providersBackstage) { 20160 var translatedOptions = map(spec.items, function (item) { 20161 return { 20162 text: providersBackstage.translate(item.text), 20163 value: item.value 20164 }; 20165 }); 20166 var pLabel = spec.label.map(function (label) { 20167 return renderLabel(label, providersBackstage); 20168 }); 20169 var pField = FormField.parts.field({ 20170 dom: {}, 20171 selectAttributes: { size: spec.size }, 20172 options: translatedOptions, 20173 factory: HtmlSelect, 20174 selectBehaviours: derive$1([ 20175 Disabling.config({ 20176 disabled: function () { 20177 return spec.disabled || providersBackstage.isDisabled(); 20178 } 20179 }), 20180 Tabstopping.config({}), 20181 config('selectbox-change', [run(change(), function (component, _) { 20182 emitWith(component, formChangeEvent, { name: spec.name }); 20183 })]) 20184 ]) 20185 }); 20186 var chevron = spec.size > 1 ? Optional.none() : Optional.some({ 20187 dom: { 20188 tag: 'div', 20189 classes: ['tox-selectfield__icon-js'], 20190 innerHtml: get$e('chevron-down', providersBackstage.icons) 20191 } 20192 }); 20193 var selectWrap = { 20194 dom: { 20195 tag: 'div', 20196 classes: ['tox-selectfield'] 20197 }, 20198 components: flatten([ 20199 [pField], 20200 chevron.toArray() 20201 ]) 20202 }; 20203 return FormField.sketch({ 20204 dom: { 20205 tag: 'div', 20206 classes: ['tox-form__group'] 20207 }, 20208 components: flatten([ 20209 pLabel.toArray(), 20210 [selectWrap] 20211 ]), 20212 fieldBehaviours: derive$1([ 20213 Disabling.config({ 20214 disabled: function () { 20215 return spec.disabled || providersBackstage.isDisabled(); 20216 }, 20217 onDisabled: function (comp) { 20218 FormField.getField(comp).each(Disabling.disable); 20219 }, 20220 onEnabled: function (comp) { 20221 FormField.getField(comp).each(Disabling.enable); 20222 } 20223 }), 20224 receivingConfig() 20225 ]) 20226 }); 20227 }; 20228 20229 var renderTable = function (spec, providersBackstage) { 20230 var renderTh = function (text) { 20231 return { 20232 dom: { 20233 tag: 'th', 20234 innerHtml: providersBackstage.translate(text) 20235 } 20236 }; 20237 }; 20238 var renderHeader = function (header) { 20239 return { 20240 dom: { tag: 'thead' }, 20241 components: [{ 20242 dom: { tag: 'tr' }, 20243 components: map(header, renderTh) 20244 }] 20245 }; 20246 }; 20247 var renderTd = function (text) { 20248 return { 20249 dom: { 20250 tag: 'td', 20251 innerHtml: providersBackstage.translate(text) 20252 } 20253 }; 20254 }; 20255 var renderTr = function (row) { 20256 return { 20257 dom: { tag: 'tr' }, 20258 components: map(row, renderTd) 20259 }; 20260 }; 20261 var renderRows = function (rows) { 20262 return { 20263 dom: { tag: 'tbody' }, 20264 components: map(rows, renderTr) 20265 }; 20266 }; 20267 return { 20268 dom: { 20269 tag: 'table', 20270 classes: ['tox-dialog__table'] 20271 }, 20272 components: [ 20273 renderHeader(spec.header), 20274 renderRows(spec.cells) 20275 ], 20276 behaviours: derive$1([ 20277 Tabstopping.config({}), 20278 Focusing.config({}) 20279 ]) 20280 }; 20281 }; 20282 20283 var renderTextField = function (spec, providersBackstage) { 20284 var pLabel = spec.label.map(function (label) { 20285 return renderLabel(label, providersBackstage); 20286 }); 20287 var baseInputBehaviours = [ 20288 Disabling.config({ 20289 disabled: function () { 20290 return spec.disabled || providersBackstage.isDisabled(); 20291 } 20292 }), 20293 receivingConfig(), 20294 Keying.config({ 20295 mode: 'execution', 20296 useEnter: spec.multiline !== true, 20297 useControlEnter: spec.multiline === true, 20298 execute: function (comp) { 20299 emit(comp, formSubmitEvent); 20300 return Optional.some(true); 20301 } 20302 }), 20303 config('textfield-change', [ 20304 run(input(), function (component, _) { 20305 emitWith(component, formChangeEvent, { name: spec.name }); 20306 }), 20307 run(postPaste(), function (component, _) { 20308 emitWith(component, formChangeEvent, { name: spec.name }); 20309 }) 20310 ]), 20311 Tabstopping.config({}) 20312 ];
20313 var validatingBehaviours = spec.validation.map(function (vl) { 20314 return Invalidating.config({ 20315 getRoot: function (input) { 20316 return parent(input.element); 20317 }, 20318 invalidClass: 'tox-invalid', 20319 validator: { 20320 validate: function (input) { 20321 var v = Representing.getValue(input); 20322 var result = vl.validator(v); 20323 return Future.pure(result === true ? Result.value(v) : Result.error(result)); 20324 }, 20325 validateOnLoad: vl.validateOnLoad 20326 } 20327 }); 20328 }).toArray(); 20329 var placeholder = spec.placeholder.fold(constant({}), function (p) { 20330 return { placeholder: providersBackstage.translate(p) }; 20331 }); 20332 var inputMode = spec.inputMode.fold(constant({}), function (mode) { 20333 return { inputmode: mode }; 20334 }); 20335 var inputAttributes = __assign(__assign({}, placeholder), inputMode); 20336 var pField = FormField.parts.field({ 20337 tag: spec.multiline === true ? 'textarea' : 'input', 20338 inputAttributes: inputAttributes, 20339 inputClasses: [spec.classname], 20340 inputBehaviours: derive$1(flatten([ 20341 baseInputBehaviours, 20342 validatingBehaviours 20343 ])), 20344 selectOnFocus: false, 20345 factory: Input 20346 }); 20347 var extraClasses = spec.flex ? ['tox-form__group--stretched'] : []; 20348 var extraClasses2 = extraClasses.concat(spec.maximized ? ['tox-form-group--maximize'] : []); 20349 var extraBehaviours = [ 20350 Disabling.config({ 20351 disabled: function () { 20352 return spec.disabled || providersBackstage.isDisabled(); 20353 }, 20354 onDisabled: function (comp) { 20355 FormField.getField(comp).each(Disabling.disable); 20356 }, 20357 onEnabled: function (comp) { 20358 FormField.getField(comp).each(Disabling.enable); 20359 } 20360 }), 20361 receivingConfig() 20362 ]; 20363 return renderFormFieldWith(pLabel, pField, extraClasses2, extraBehaviours); 20364 }; 20365 var renderInput = function (spec, providersBackstage) { 20366 return renderTextField({ 20367 name: spec.name, 20368 multiline: false, 20369 label: spec.label, 20370 inputMode: spec.inputMode, 20371 placeholder: spec.placeholder, 20372 flex: false, 20373 disabled: spec.disabled, 20374 classname: 'tox-textfield', 20375 validation: Optional.none(), 20376 maximized: spec.maximized 20377 }, providersBackstage); 20378 }; 20379 var renderTextarea = function (spec, providersBackstage) { 20380 return renderTextField({ 20381 name: spec.name, 20382 multiline: true, 20383 label: spec.label, 20384 inputMode: Optional.none(), 20385 placeholder: spec.placeholder, 20386 flex: true, 20387 disabled: spec.disabled, 20388 classname: 'tox-textarea', 20389 validation: Optional.none(), 20390 maximized: spec.maximized 20391 }, providersBackstage); 20392 }; 20393 20394 var events$c = function (streamConfig, streamState) { 20395 var streams = streamConfig.stream.streams; 20396 var processor = streams.setup(streamConfig, streamState); 20397 return derive([ 20398 run(streamConfig.event, processor), 20399 runOnDetached(function () { 20400 return streamState.cancel(); 20401 }) 20402 ].concat(streamConfig.cancelEvent.map(function (e) { 20403 return [run(e, function () { 20404 return streamState.cancel(); 20405 })]; 20406 }).getOr([]))); 20407 }; 20408 20409 var ActiveStreaming = /*#__PURE__*/Object.freeze({ 20410 __proto__: null, 20411 events: events$c 20412 }); 20413 20414 var throttle = function (_config) { 20415 var state = Cell(null); 20416 var readState = function () { 20417 return { timer: state.get() !== null ? 'set' : 'unset' }; 20418 }; 20419 var setTimer = function (t) { 20420 state.set(t); 20421 }; 20422 var cancel = function () { 20423 var t = state.get(); 20424 if (t !== null) { 20425 t.cancel(); 20426 } 20427 }; 20428 return nu$5({ 20429 readState: readState, 20430 setTimer: setTimer, 20431 cancel: cancel 20432 }); 20433 }; 20434 var init$6 = function (spec) { 20435 return spec.stream.streams.state(spec); 20436 }; 20437 20438 var StreamingState = /*#__PURE__*/Object.freeze({ 20439 __proto__: null, 20440 throttle: throttle, 20441 init: init$6 20442 }); 20443 20444 var setup$2 = function (streamInfo, streamState) { 20445 var sInfo = streamInfo.stream; 20446 var throttler = last$2(streamInfo.onStream, sInfo.delay); 20447 streamState.setTimer(throttler); 20448 return function (component, simulatedEvent) { 20449 throttler.throttle(component, simulatedEvent); 20450 if (sInfo.stopEvent) { 20451 simulatedEvent.stop(); 20452 } 20453 }; 20454 }; 20455 var StreamingSchema = [
20456 strictOf('stream', choose$1('mode', { 20457 throttle: [ 20458 strict$1('delay'), 20459 defaulted$1('stopEvent', true), 20460 output('streams', { 20461 setup: setup$2, 20462 state: throttle 20463 }) 20464 ] 20465 })), 20466 defaulted$1('event', 'input'), 20467 option('cancelEvent'), 20468 onStrictHandler('onStream') 20469 ]; 20470 20471 var Streaming = create$1({ 20472 fields: StreamingSchema, 20473 name: 'streaming', 20474 active: ActiveStreaming, 20475 state: StreamingState 20476 }); 20477 20478 var setValueFromItem = function (model, input, item) { 20479 var itemData = Representing.getValue(item); 20480 Representing.setValue(input, itemData); 20481 setCursorAtEnd(input); 20482 }; 20483 var setSelectionOn = function (input, f) { 20484 var el = input.element; 20485 var value = get$6(el); 20486 var node = el.dom; 20487 if (get$3(el, 'type') !== 'number') { 20488 f(node, value); 20489 } 20490 }; 20491 var setCursorAtEnd = function (input) { 20492 setSelectionOn(input, function (node, value) { 20493 return node.setSelectionRange(value.length, value.length); 20494 }); 20495 }; 20496 var setSelectionToEnd = function (input, startOffset) { 20497 setSelectionOn(input, function (node, value) { 20498 return node.setSelectionRange(startOffset, value.length); 20499 }); 20500 }; 20501 var attemptSelectOver = function (model, input, item) { 20502 if (!model.selectsOver) { 20503 return Optional.none(); 20504 } else { 20505 var currentValue = Representing.getValue(input); 20506 var inputDisplay_1 = model.getDisplayText(currentValue); 20507 var itemValue = Representing.getValue(item); 20508 var itemDisplay = model.getDisplayText(itemValue); 20509 return itemDisplay.indexOf(inputDisplay_1) === 0 ? Optional.some(function () { 20510 setValueFromItem(model, input, item); 20511 setSelectionToEnd(input, inputDisplay_1.length); 20512 }) : Optional.none(); 20513 } 20514 }; 20515 20516 var itemExecute = constant('alloy.typeahead.itemexecute'); 20517 20518 var make$5 = function (detail, components, spec, externals) { 20519 var navigateList = function (comp, simulatedEvent, highlighter) { 20520 detail.previewing.set(false); 20521 var sandbox = Coupling.getCoupled(comp, 'sandbox'); 20522 if (Sandboxing.isOpen(sandbox)) { 20523 Composing.getCurrent(sandbox).each(function (menu) { 20524 Highlighting.getHighlighted(menu).fold(function () { 20525 highlighter(menu); 20526 }, function () { 20527 dispatchEvent(sandbox, menu.element, 'keydown', simulatedEvent); 20528 }); 20529 }); 20530 } else { 20531 var onOpenSync = function (sandbox) { 20532 Composing.getCurrent(sandbox).each(highlighter); 20533 }; 20534 open$1(detail, mapFetch(comp), comp, sandbox, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop); 20535 } 20536 }; 20537 var focusBehaviours$1 = focusBehaviours(detail); 20538 var mapFetch = function (comp) { 20539 return function (tdata) { 20540 return tdata.map(function (data) { 20541 var menus = values(data.menus); 20542 var items = bind(menus, function (menu) { 20543 return filter(menu.items, function (item) { 20544 return item.type === 'item'; 20545 }); 20546 }); 20547 var repState = Representing.getState(comp); 20548 repState.update(map(items, function (item) { 20549 return item.data; 20550 })); 20551 return data; 20552 }); 20553 }; 20554 }; 20555 var behaviours = [ 20556 Focusing.config({}), 20557 Representing.config({ 20558 onSetValue: detail.onSetValue, 20559 store: __assign({ 20560 mode: 'dataset', 20561 getDataKey: function (comp) { 20562 return get$6(comp.element); 20563 }, 20564 getFallbackEntry: function (itemString) { 20565 return { 20566 value: itemString, 20567 meta: {} 20568 }; 20569 }, 20570 setValue: function (comp, data) { 20571 set$3(comp.element, detail.model.getDisplayText(data)); 20572 } 20573 }, detail.initialData.map(function (d) { 20574 return wrap$1('initialValue', d); 20575 }).getOr({})) 20576 }), 20577 Streaming.config({ 20578 stream: { 20579 mode: 'throttle', 20580 delay: detail.responseTime, 20581 stopEvent: false 20582 }, 20583 onStream: function (component, _simulatedEvent) { 20584 var sandbox = Coupling.getCoupled(component, 'sandbox'); 20585 var focusInInput = Focusing.isFocused(component); 20586 if (focusInInput) { 20587 if (get$6(component.element).length >= detail.minChars) { 20588 var previousValue_1 = Composing.getCurrent(sandbox).bind(function (menu) { 20589 return Highlighting.getHighlighted(menu).map(Representing.getValue); 20590 }); 20591 detail.previewing.set(true); 20592 var onOpenSync = function (_sandbox) { 20593 Composing.getCurrent(sandbox).each(function (menu) { 20594 previousValue_1.fold(function () { 20595 if (detail.model.selectsOver) { 20596 Highlighting.highlightFirst(menu); 20597 } 20598 }, function (pv) { 20599 Highlighting.highlightBy(menu, function (item) { 20600 var itemData = Representing.getValue(item); 20601 return itemData.value === pv.value; 20602 }); 20603 Highlighting.getHighlighted(menu).orThunk(function () { 20604 Highlighting.highlightFirst(menu); 20605 return Optional.none(); 20606 }); 20607 }); 20608 }); 20609 }; 20610 open$1(detail, mapFetch(component), component, sandbox, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop); 20611 } 20612 } 20613 }, 20614 cancelEvent: typeaheadCancel() 20615 }), 20616 Keying.config({
20617 mode: 'special', 20618 onDown: function (comp, simulatedEvent) { 20619 navigateList(comp, simulatedEvent, Highlighting.highlightFirst); 20620 return Optional.some(true); 20621 }, 20622 onEscape: function (comp) { 20623 var sandbox = Coupling.getCoupled(comp, 'sandbox'); 20624 if (Sandboxing.isOpen(sandbox)) { 20625 Sandboxing.close(sandbox); 20626 return Optional.some(true); 20627 } 20628 return Optional.none(); 20629 }, 20630 onUp: function (comp, simulatedEvent) { 20631 navigateList(comp, simulatedEvent, Highlighting.highlightLast); 20632 return Optional.some(true); 20633 }, 20634 onEnter: function (comp) { 20635 var sandbox = Coupling.getCoupled(comp, 'sandbox'); 20636 var sandboxIsOpen = Sandboxing.isOpen(sandbox); 20637 if (sandboxIsOpen && !detail.previewing.get()) { 20638 return Composing.getCurrent(sandbox).bind(function (menu) { 20639 return Highlighting.getHighlighted(menu); 20640 }).map(function (item) { 20641 emitWith(comp, itemExecute(), { item: item }); 20642 return true; 20643 }); 20644 } else { 20645 var currentValue = Representing.getValue(comp); 20646 emit(comp, typeaheadCancel()); 20647 detail.onExecute(sandbox, comp, currentValue); 20648 if (sandboxIsOpen) { 20649 Sandboxing.close(sandbox); 20650 } 20651 return Optional.some(true); 20652 } 20653 } 20654 }), 20655 Toggling.config({ 20656 toggleClass: detail.markers.openClass, 20657 aria: { mode: 'expanded' } 20658 }), 20659 Coupling.config({ 20660 others: { 20661 sandbox: function (hotspot) { 20662 return makeSandbox(detail, hotspot, { 20663 onOpen: function () { 20664 return Toggling.on(hotspot); 20665 }, 20666 onClose: function () { 20667 return Toggling.off(hotspot); 20668 } 20669 }); 20670 } 20671 } 20672 }), 20673 config('typeaheadevents', [ 20674 runOnExecute(function (comp) { 20675 var onOpenSync = noop; 20676 togglePopup(detail, mapFetch(comp), comp, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop); 20677 }), 20678 run(itemExecute(), function (comp, se) { 20679 var sandbox = Coupling.getCoupled(comp, 'sandbox'); 20680 setValueFromItem(detail.model, comp, se.event.item); 20681 emit(comp, typeaheadCancel()); 20682 detail.onItemExecute(comp, sandbox, se.event.item, Representing.getValue(comp)); 20683 Sandboxing.close(sandbox); 20684 setCursorAtEnd(comp); 20685 }) 20686 ].concat(detail.dismissOnBlur ? [run(postBlur(), function (typeahead) { 20687 var sandbox = Coupling.getCoupled(typeahead, 'sandbox'); 20688 if (search(sandbox.element).isNone()) { 20689 Sandboxing.close(sandbox); 20690 } 20691 })] : [])) 20692 ]; 20693 return { 20694 uid: detail.uid, 20695 dom: dom$2(deepMerge(detail, { 20696 inputAttributes: { 20697 'role': 'combobox', 20698 'aria-autocomplete': 'list', 20699 'aria-haspopup': 'true' 20700 } 20701 })), 20702 behaviours: __assign(__assign({}, focusBehaviours$1), augment(detail.typeaheadBehaviours, behaviours)), 20703 eventOrder: detail.eventOrder 20704 }; 20705 }; 20706 20707 var schema$j = constant([ 20708 option('lazySink'), 20709 strict$1('fetch'), 20710 defaulted$1('minChars', 5), 20711 defaulted$1('responseTime', 1000), 20712 onHandler('onOpen'), 20713 defaulted$1('getHotspot', Optional.some), 20714 defaulted$1('getAnchorOverrides', constant({})), 20715 defaulted$1('layouts', Optional.none()), 20716 defaulted$1('eventOrder', {}), 20717 defaultedObjOf('model', {}, [ 20718 defaulted$1('getDisplayText', function (itemData) { 20719 return itemData.meta !== undefined && itemData.meta.text !== undefined ? itemData.meta.text : itemData.value; 20720 }), 20721 defaulted$1('selectsOver', true), 20722 defaulted$1('populateFromBrowse', true) 20723 ]), 20724 onHandler('onSetValue'), 20725 onKeyboardHandler('onExecute'), 20726 onHandler('onItemExecute'), 20727 defaulted$1('inputClasses', []), 20728 defaulted$1('inputAttributes', {}), 20729 defaulted$1('inputStyles', {}), 20730 defaulted$1('matchWidth', true), 20731 defaulted$1('useMinWidth', false), 20732 defaulted$1('dismissOnBlur', true), 20733 markers(['openClass']), 20734 option('initialData'), 20735 field$1('typeaheadBehaviours', [ 20736 Focusing, 20737 Representing, 20738 Streaming, 20739 Keying, 20740 Toggling, 20741 Coupling 20742 ]), 20743 state$1('previewing', function () { 20744 return Cell(true); 20745 }) 20746 ].concat(schema$f()).concat(sandboxFields())); 20747 var parts$6 = constant([external$1({ 20748 schema: [tieredMenuMarkers()], 20749 name: 'menu', 20750 overrides: function (detail) { 20751 return { 20752 fakeFocus: true, 20753 onHighlight: function (menu, item) { 20754 if (!detail.previewing.get()) { 20755 menu.getSystem().getByUid(detail.uid).each(function (input) { 20756 if (detail.model.populateFromBrowse) { 20757 setValueFromItem(detail.model, input, item); 20758 } 20759 }); 20760 } else { 20761 menu.getSystem().getByUid(detail.uid).each(function (input) { 20762 attemptSelectOver(detail.model, input, item).fold(function () { 20763 return Highlighting.dehighlight(menu, item); 20764 }, function (fn) { 20765 return fn(); 20766 }); 20767 }); 20768 } 20769 detail.previewing.set(false); 20770 }, 20771 onExecute: function (menu, item) { 20772 return menu.getSystem().getByUid(detail.uid).toOptional().map(function (typeahead) { 20773 emitWith(typeahead, itemExecute(), { item: item }); 20774 return true; 20775 }); 20776 }, 20777 onHover: function (menu, item) { 20778 detail.previewing.set(false); 20779 menu.getSystem().getByUid(detail.uid).each(function (input) { 20780 if (detail.model.populateFromBrowse) { 20781 setValueFromItem(detail.model, input, item); 20782 } 20783 }); 20784 } 20785 }; 20786 } 20787 })]); 20788 20789 var Typeahead = composite$1({ 20790 name: 'Typeahead', 20791 configFields: schema$j(), 20792 partFields: parts$6(), 20793 factory: make$5 20794 }); 20795 20796 var wrap$2 = function (delegate) { 20797 var toCached = function () { 20798 return wrap$2(delegate.toCached()); 20799 }; 20800 var bindFuture = function (f) { 20801 return wrap$2(delegate.bind(function (resA) { 20802 return resA.fold(function (err) { 20803 return Future.pure(Result.error(err)); 20804 }, function (a) { 20805 return f(a); 20806 }); 20807 })); 20808 }; 20809 var bindResult = function (f) { 20810 return wrap$2(delegate.map(function (resA) { 20811 return resA.bind(f); 20812 })); 20813 }; 20814 var mapResult = function (f) { 20815 return wrap$2(delegate.map(function (resA) { 20816 return resA.map(f); 20817 })); 20818 }; 20819 var mapError = function (f) { 20820 return wrap$2(delegate.map(function (resA) { 20821 return resA.mapError(f); 20822 })); 20823 }; 20824 var foldResult = function (whenError, whenValue) { 20825 return delegate.map(function (res) { 20826 return res.fold(whenError, whenValue); 20827 }); 20828 }; 20829 var withTimeout = function (timeout, errorThunk) { 20830 return wrap$2(Future.nu(function (callback) { 20831 var timedOut = false;
20832 var timer = setTimeout(function () { 20833 timedOut = true; 20834 callback(Result.error(errorThunk())); 20835 }, timeout); 20836 delegate.get(function (result) { 20837 if (!timedOut) { 20838 clearTimeout(timer); 20839 callback(result); 20840 } 20841 }); 20842 })); 20843 }; 20844 return __assign(__assign({}, delegate), { 20845 toCached: toCached, 20846 bindFuture: bindFuture, 20847 bindResult: bindResult, 20848 mapResult: mapResult, 20849 mapError: mapError, 20850 foldResult: foldResult, 20851 withTimeout: withTimeout 20852 }); 20853 }; 20854 var nu$c = function (worker) { 20855 return wrap$2(Future.nu(worker)); 20856 }; 20857 var value$2 = function (value) { 20858 return wrap$2(Future.pure(Result.value(value))); 20859 }; 20860 var error$1 = function (error) { 20861 return wrap$2(Future.pure(Result.error(error))); 20862 }; 20863 var fromResult$1 = function (result) { 20864 return wrap$2(Future.pure(result)); 20865 }; 20866 var fromFuture = function (future) { 20867 return wrap$2(future.map(Result.value)); 20868 }; 20869 var fromPromise = function (promise) { 20870 return nu$c(function (completer) { 20871 promise.then(function (value) { 20872 completer(Result.value(value)); 20873 }, function (error) { 20874 completer(Result.error(error)); 20875 }); 20876 }); 20877 }; 20878 var FutureResult = { 20879 nu: nu$c, 20880 wrap: wrap$2, 20881 pure: value$2, 20882 value: value$2, 20883 error: error$1, 20884 fromResult: fromResult$1, 20885 fromFuture: fromFuture, 20886 fromPromise: fromPromise 20887 }; 20888 20889 var separator$2 = { type: 'separator' }; 20890 var toMenuItem = function (target) { 20891 return { 20892 type: 'menuitem', 20893 value: target.url, 20894 text: target.title, 20895 meta: { attach: target.attach }, 20896 onAction: noop 20897 }; 20898 }; 20899 var staticMenuItem = function (title, url) { 20900 return { 20901 type: 'menuitem', 20902 value: url, 20903 text: title, 20904 meta: { attach: undefined }, 20905 onAction: noop 20906 }; 20907 }; 20908 var toMenuItems = function (targets) { 20909 return map(targets, toMenuItem); 20910 }; 20911 var filterLinkTargets = function (type, targets) { 20912 return filter(targets, function (target) { 20913 return target.type === type; 20914 }); 20915 }; 20916 var filteredTargets = function (type, targets) { 20917 return toMenuItems(filterLinkTargets(type, targets)); 20918 }; 20919 var headerTargets = function (linkInfo) { 20920 return filteredTargets('header', linkInfo.targets); 20921 }; 20922 var anchorTargets = function (linkInfo) { 20923 return filteredTargets('anchor', linkInfo.targets); 20924 }; 20925 var anchorTargetTop = function (linkInfo) {
20926 return Optional.from(linkInfo.anchorTop).map(function (url) { 20927 return staticMenuItem('<top>', url); 20928 }).toArray(); 20929 }; 20930 var anchorTargetBottom = function (linkInfo) { 20931 return Optional.from(linkInfo.anchorBottom).map(function (url) { 20932 return staticMenuItem('<bottom>', url); 20933 }).toArray(); 20934 }; 20935 var historyTargets = function (history) { 20936 return map(history, function (url) { 20937 return staticMenuItem(url, url); 20938 }); 20939 }; 20940 var joinMenuLists = function (items) { 20941 return foldl(items, function (a, b) { 20942 var bothEmpty = a.length === 0 || b.length === 0; 20943 return bothEmpty ? a.concat(b) : a.concat(separator$2, b); 20944 }, []); 20945 }; 20946 var filterByQuery = function (term, menuItems) { 20947 var lowerCaseTerm = term.toLowerCase(); 20948 return filter(menuItems, function (item) { 20949 var text = item.meta !== undefined && item.meta.text !== undefined ? item.meta.text : item.text; 20950 return contains$1(text.toLowerCase(), lowerCaseTerm) || contains$1(item.value.toLowerCase(), lowerCaseTerm); 20951 }); 20952 }; 20953 20954 var getItems = function (fileType, input, urlBackstage) { 20955 var urlInputValue = Representing.getValue(input); 20956 var term = urlInputValue.meta.text !== undefined ? urlInputValue.meta.text : urlInputValue.value; 20957 var info = urlBackstage.getLinkInformation(); 20958 return info.fold(function () { 20959 return []; 20960 }, function (linkInfo) { 20961 var history = filterByQuery(term, historyTargets(urlBackstage.getHistory(fileType))); 20962 return fileType === 'file' ? joinMenuLists([ 20963 history, 20964 filterByQuery(term, headerTargets(linkInfo)), 20965 filterByQuery(term, flatten([ 20966 anchorTargetTop(linkInfo), 20967 anchorTargets(linkInfo), 20968 anchorTargetBottom(linkInfo) 20969 ])) 20970 ]) : history; 20971 }); 20972 }; 20973 var errorId = generate$1('aria-invalid'); 20974 var renderUrlInput = function (spec, backstage, urlBackstage) { 20975 var _a; 20976 var providersBackstage = backstage.shared.providers; 20977 var updateHistory = function (component) { 20978 var urlEntry = Representing.getValue(component); 20979 urlBackstage.addToHistory(urlEntry.value, spec.filetype); 20980 }; 20981 var pField = FormField.parts.field({ 20982 factory: Typeahead, 20983 dismissOnBlur: true, 20984 inputClasses: ['tox-textfield'], 20985 sandboxClasses: ['tox-dialog__popups'], 20986 inputAttributes: { 20987 'aria-errormessage': errorId, 20988 'type': 'url' 20989 }, 20990 minChars: 0, 20991 responseTime: 0, 20992 fetch: function (input) { 20993 var items = getItems(spec.filetype, input, urlBackstage); 20994 var tdata = build$2(items, ItemResponse$1.BUBBLE_TO_SANDBOX, backstage, false); 20995 return Future.pure(tdata); 20996 }, 20997 getHotspot: function (comp) { 20998 return memUrlBox.getOpt(comp); 20999 }, 21000 onSetValue: function (comp, _newValue) { 21001 if (comp.hasConfigured(Invalidating)) { 21002 Invalidating.run(comp).get(noop); 21003 } 21004 }, 21005 typeaheadBehaviours: derive$1(flatten([ 21006 urlBackstage.getValidationHandler().map(function (handler) { 21007 return Invalidating.config({ 21008 getRoot: function (comp) { 21009 return parent(comp.element); 21010 }, 21011 invalidClass: 'tox-control-wrap--status-invalid', 21012 notify: { 21013 onInvalid: function (comp, err) { 21014 memInvalidIcon.getOpt(comp).each(function (invalidComp) { 21015 set$1(invalidComp.element, 'title', providersBackstage.translate(err)); 21016 }); 21017 } 21018 }, 21019 validator: { 21020 validate: function (input) { 21021 var urlEntry = Representing.getValue(input); 21022 return FutureResult.nu(function (completer) { 21023 handler({ 21024 type: spec.filetype, 21025 url: urlEntry.value 21026 }, function (validation) {
21027 if (validation.status === 'invalid') { 21028 var err = Result.error(validation.message); 21029 completer(err); 21030 } else { 21031 var val = Result.value(validation.message); 21032 completer(val); 21033 } 21034 }); 21035 }); 21036 }, 21037 validateOnLoad: false 21038 } 21039 }); 21040 }).toArray(), 21041 [ 21042 Disabling.config({ 21043 disabled: function () { 21044 return spec.disabled || providersBackstage.isDisabled(); 21045 } 21046 }), 21047 Tabstopping.config({}), 21048 config('urlinput-events', flatten([ 21049 spec.filetype === 'file' ? [run(input(), function (comp) { 21050 emitWith(comp, formChangeEvent, { name: spec.name }); 21051 })] : [], 21052 [ 21053 run(change(), function (comp) { 21054 emitWith(comp, formChangeEvent, { name: spec.name }); 21055 updateHistory(comp); 21056 }), 21057 run(postPaste(), function (comp) { 21058 emitWith(comp, formChangeEvent, { name: spec.name }); 21059 updateHistory(comp); 21060 }) 21061 ] 21062 ])) 21063 ] 21064 ])), 21065 eventOrder: (_a = {}, _a[input()] = [ 21066 'streaming', 21067 'urlinput-events', 21068 'invalidating' 21069 ], _a), 21070 model: { 21071 getDisplayText: function (itemData) { 21072 return itemData.value; 21073 }, 21074 selectsOver: false, 21075 populateFromBrowse: false 21076 }, 21077 markers: { openClass: 'tox-textfield--popup-open' }, 21078 lazySink: backstage.shared.getSink, 21079 parts: { menu: part(false, 1, 'normal') }, 21080 onExecute: function (_menu, component, _entry) { 21081 emitWith(component, formSubmitEvent, {}); 21082 }, 21083 onItemExecute: function (typeahead, _sandbox, _item, _value) { 21084 updateHistory(typeahead); 21085 emitWith(typeahead, formChangeEvent, { name: spec.name }); 21086 } 21087 }); 21088 var pLabel = spec.label.map(function (label) { 21089 return renderLabel(label, providersBackstage); 21090 }); 21091 var makeIcon = function (name, errId, icon, label) { 21092 if (icon === void 0) { 21093 icon = name; 21094 } 21095 if (label === void 0) { 21096 label = name; 21097 } 21098 return { 21099 dom: { 21100 tag: 'div', 21101 classes: [ 21102 'tox-icon', 21103 'tox-control-wrap__status-icon-' + name 21104 ], 21105 innerHtml: get$e(icon, providersBackstage.icons), 21106 attributes: __assign({ 21107 'title': providersBackstage.translate(label), 21108 'aria-live': 'polite' 21109 }, errId.fold(function () { 21110 return {}; 21111 }, function (id) { 21112 return { id: id }; 21113 })) 21114 } 21115 }; 21116 }; 21117 var memInvalidIcon = record(makeIcon('invalid', Optional.some(errorId), 'warning')); 21118 var memStatus = record({ 21119 dom: { 21120 tag: 'div', 21121 classes: ['tox-control-wrap__status-icon-wrap'] 21122 }, 21123 components: [memInvalidIcon.asSpec()] 21124 }); 21125 var optUrlPicker = urlBackstage.getUrlPicker(spec.filetype); 21126 var browseUrlEvent = generate$1('browser.url.event'); 21127 var memUrlBox = record({ 21128 dom: { 21129 tag: 'div', 21130 classes: ['tox-control-wrap'] 21131 }, 21132 components: [ 21133 pField, 21134 memStatus.asSpec() 21135 ], 21136 behaviours: derive$1([Disabling.config({ 21137 disabled: function () { 21138 return spec.disabled || providersBackstage.isDisabled(); 21139 } 21140 })]) 21141 }); 21142 var memUrlPickerButton = record(renderButton({ 21143 name: spec.name, 21144 icon: Optional.some('browse'), 21145 text: spec.label.getOr(''), 21146 disabled: spec.disabled, 21147 primary: false, 21148 borderless: true 21149 }, function (component) { 21150 return emit(component, browseUrlEvent); 21151 }, providersBackstage, [], ['tox-browse-url'])); 21152 var controlHWrapper = function () { 21153 return { 21154 dom: { 21155 tag: 'div', 21156 classes: ['tox-form__controls-h-stack'] 21157 }, 21158 components: flatten([ 21159 [memUrlBox.asSpec()], 21160 optUrlPicker.map(function () { 21161 return memUrlPickerButton.asSpec(); 21162 }).toArray() 21163 ]) 21164 }; 21165 }; 21166 var openUrlPicker = function (comp) { 21167 Composing.getCurrent(comp).each(function (field) { 21168 var componentData = Representing.getValue(field); 21169 var urlData = __assign({ fieldname: spec.name }, componentData); 21170 optUrlPicker.each(function (picker) { 21171 picker(urlData).get(function (chosenData) { 21172 Representing.setValue(field, chosenData); 21173 emitWith(comp, formChangeEvent, { name: spec.name }); 21174 }); 21175 }); 21176 }); 21177 }; 21178 return FormField.sketch({ 21179 dom: renderFormFieldDom(), 21180 components: pLabel.toArray().concat([controlHWrapper()]), 21181 fieldBehaviours: derive$1([ 21182 Disabling.config({ 21183 disabled: function () { 21184 return spec.disabled || providersBackstage.isDisabled(); 21185 }, 21186 onDisabled: function (comp) { 21187 FormField.getField(comp).each(Disabling.disable); 21188 memUrlPickerButton.getOpt(comp).each(Disabling.disable); 21189 }, 21190 onEnabled: function (comp) { 21191 FormField.getField(comp).each(Disabling.enable); 21192 memUrlPickerButton.getOpt(comp).each(Disabling.enable); 21193 } 21194 }), 21195 receivingConfig(), 21196 config('url-input-events', [run(browseUrlEvent, openUrlPicker)]) 21197 ]) 21198 }); 21199 }; 21200 21201 var renderAlertBanner = function (spec, providersBackstage) { 21202 return Container.sketch({ 21203 dom: { 21204 tag: 'div', 21205 attributes: { role: 'alert' }, 21206 classes: [ 21207 'tox-notification', 21208 'tox-notification--in', 21209 'tox-notification--' + spec.level 21210 ] 21211 }, 21212 components: [ 21213 { 21214 dom: { 21215 tag: 'div', 21216 classes: ['tox-notification__icon'] 21217 }, 21218 components: [Button.sketch({ 21219 dom: { 21220 tag: 'button', 21221 classes: [ 21222 'tox-button', 21223 'tox-button--naked', 21224 'tox-button--icon' 21225 ], 21226 innerHtml: get$e(spec.icon, providersBackstage.icons), 21227 attributes: { title: providersBackstage.translate(spec.iconTooltip) } 21228 }, 21229 action: function (comp) { 21230 emitWith(comp, formActionEvent, { 21231 name: 'alert-banner', 21232 value: spec.url 21233 }); 21234 } 21235 })] 21236 }, 21237 { 21238 dom: { 21239 tag: 'div', 21240 classes: ['tox-notification__body'], 21241 innerHtml: providersBackstage.translate(spec.text) 21242 } 21243 } 21244 ] 21245 }); 21246 }; 21247 21248 var renderCheckbox = function (spec, providerBackstage) { 21249 var repBehaviour = Representing.config({ 21250 store: { 21251 mode: 'manual', 21252 getValue: function (comp) { 21253 var el = comp.element.dom; 21254 return el.checked; 21255 }, 21256 setValue: function (comp, value) { 21257 var el = comp.element.dom; 21258 el.checked = value; 21259 } 21260 } 21261 }); 21262 var toggleCheckboxHandler = function (comp) { 21263 comp.element.dom.click(); 21264 return Optional.some(true); 21265 }; 21266 var pField = FormField.parts.field({ 21267 factory: { sketch: identity }, 21268 dom: { 21269 tag: 'input', 21270 classes: ['tox-checkbox__input'], 21271 attributes: { type: 'checkbox' } 21272 }, 21273 behaviours: derive$1([ 21274 ComposingConfigs.self(), 21275 Disabling.config({ 21276 disabled: function () { 21277 return spec.disabled || providerBackstage.isDisabled(); 21278 } 21279 }), 21280 Tabstopping.config({}), 21281 Focusing.config({}), 21282 repBehaviour, 21283 Keying.config({
21284 mode: 'special', 21285 onEnter: toggleCheckboxHandler, 21286 onSpace: toggleCheckboxHandler, 21287 stopSpaceKeyup: true 21288 }), 21289 config('checkbox-events', [run(change(), function (component, _) { 21290 emitWith(component, formChangeEvent, { name: spec.name }); 21291 })]) 21292 ]) 21293 }); 21294 var pLabel = FormField.parts.label({ 21295 dom: { 21296 tag: 'span', 21297 classes: ['tox-checkbox__label'], 21298 innerHtml: providerBackstage.translate(spec.label) 21299 }, 21300 behaviours: derive$1([Unselecting.config({})]) 21301 }); 21302 var makeIcon = function (className) { 21303 var iconName = className === 'checked' ? 'selected' : 'unselected'; 21304 return { 21305 dom: { 21306 tag: 'span', 21307 classes: [ 21308 'tox-icon', 21309 'tox-checkbox-icon__' + className 21310 ], 21311 innerHtml: get$e(iconName, providerBackstage.icons) 21312 } 21313 }; 21314 }; 21315 var memIcons = record({ 21316 dom: { 21317 tag: 'div', 21318 classes: ['tox-checkbox__icons'] 21319 }, 21320 components: [ 21321 makeIcon('checked'), 21322 makeIcon('unchecked') 21323 ] 21324 }); 21325 return FormField.sketch({ 21326 dom: { 21327 tag: 'label', 21328 classes: ['tox-checkbox'] 21329 }, 21330 components: [ 21331 pField, 21332 memIcons.asSpec(), 21333 pLabel 21334 ], 21335 fieldBehaviours: derive$1([ 21336 Disabling.config({ 21337 disabled: function () { 21338 return spec.disabled || providerBackstage.isDisabled(); 21339 }, 21340 disableClass: 'tox-checkbox--disabled', 21341 onDisabled: function (comp) { 21342 FormField.getField(comp).each(Disabling.disable); 21343 }, 21344 onEnabled: function (comp) { 21345 FormField.getField(comp).each(Disabling.enable); 21346 } 21347 }), 21348 receivingConfig() 21349 ]) 21350 }); 21351 }; 21352 21353 var renderHtmlPanel = function (spec) { 21354 if (spec.presets === 'presentation') { 21355 return Container.sketch({ 21356 dom: { 21357 tag: 'div', 21358 classes: ['tox-form__group'], 21359 innerHtml: spec.html 21360 } 21361 }); 21362 } else { 21363 return Container.sketch({ 21364 dom: { 21365 tag: 'div', 21366 classes: ['tox-form__group'], 21367 innerHtml: spec.html, 21368 attributes: { role: 'document' } 21369 }, 21370 containerBehaviours: derive$1([ 21371 Tabstopping.config({}), 21372 Focusing.config({}) 21373 ]) 21374 }); 21375 } 21376 }; 21377 21378 var make$6 = function (render) { 21379 return function (parts, spec, backstage) { 21380 return get$1(spec, 'name').fold(function () { 21381 return render(spec, backstage); 21382 }, function (fieldName) { 21383 return parts.field(fieldName, render(spec, backstage)); 21384 }); 21385 }; 21386 }; 21387 var makeIframe = function (render) { 21388 return function (parts, spec, backstage) { 21389 var iframeSpec = deepMerge(spec, { source: 'dynamic' }); 21390 return make$6(render)(parts, iframeSpec, backstage); 21391 }; 21392 }; 21393 var factories = { 21394 bar: make$6(function (spec, backstage) { 21395 return renderBar(spec, backstage.shared); 21396 }), 21397 collection: make$6(function (spec, backstage) { 21398 return renderCollection(spec, backstage.shared.providers); 21399 }), 21400 alertbanner: make$6(function (spec, backstage) { 21401 return renderAlertBanner(spec, backstage.shared.providers); 21402 }), 21403 input: make$6(function (spec, backstage) { 21404 return renderInput(spec, backstage.shared.providers); 21405 }), 21406 textarea: make$6(function (spec, backstage) { 21407 return renderTextarea(spec, backstage.shared.providers); 21408 }), 21409 label: make$6(function (spec, backstage) { 21410 return renderLabel$2(spec, backstage.shared); 21411 }), 21412 iframe: makeIframe(function (spec, backstage) { 21413 return renderIFrame(spec, backstage.shared.providers); 21414 }), 21415 button: make$6(function (spec, backstage) { 21416 return renderDialogButton(spec, backstage.shared.providers); 21417 }), 21418 checkbox: make$6(function (spec, backstage) { 21419 return renderCheckbox(spec, backstage.shared.providers); 21420 }), 21421 colorinput: make$6(function (spec, backstage) { 21422 return renderColorInput(spec, backstage.shared, backstage.colorinput); 21423 }), 21424 colorpicker: make$6(renderColorPicker), 21425 dropzone: make$6(function (spec, backstage) { 21426 return renderDropZone(spec, backstage.shared.providers); 21427 }), 21428 grid: make$6(function (spec, backstage) { 21429 return renderGrid(spec, backstage.shared); 21430 }), 21431 listbox: make$6(function (spec, backstage) {
21432 return renderListBox(spec, backstage); 21433 }), 21434 selectbox: make$6(function (spec, backstage) { 21435 return renderSelectBox(spec, backstage.shared.providers); 21436 }), 21437 sizeinput: make$6(function (spec, backstage) { 21438 return renderSizeInput(spec, backstage.shared.providers); 21439 }), 21440 urlinput: make$6(function (spec, backstage) { 21441 return renderUrlInput(spec, backstage, backstage.urlinput); 21442 }), 21443 customeditor: make$6(renderCustomEditor), 21444 htmlpanel: make$6(renderHtmlPanel), 21445 imagetools: make$6(function (spec, backstage) { 21446 return renderImageTools(spec, backstage.shared.providers); 21447 }), 21448 table: make$6(function (spec, backstage) { 21449 return renderTable(spec, backstage.shared.providers); 21450 }), 21451 panel: make$6(function (spec, backstage) { 21452 return renderPanel(spec, backstage); 21453 }) 21454 }; 21455 var noFormParts = { 21456 field: function (_name, spec) { 21457 return spec; 21458 } 21459 }; 21460 var interpretInForm = function (parts, spec, oldBackstage) { 21461 var newBackstage = deepMerge(oldBackstage, { 21462 shared: { 21463 interpreter: function (childSpec) { 21464 return interpretParts(parts, childSpec, newBackstage); 21465 } 21466 } 21467 }); 21468 return interpretParts(parts, spec, newBackstage); 21469 }; 21470 var interpretParts = function (parts, spec, backstage) { 21471 return get$1(factories, spec.type).fold(function () { 21472 console.error('Unknown factory type "' + spec.type + '", defaulting to container: ', spec); 21473 return spec; 21474 }, function (factory) { 21475 return factory(parts, spec, backstage); 21476 }); 21477 }; 21478 var interpretWithoutForm = function (spec, backstage) { 21479 var parts = noFormParts; 21480 return interpretParts(parts, spec, backstage); 21481 }; 21482 21483 var bubbleAlignments = { 21484 valignCentre: [], 21485 alignCentre: [], 21486 alignLeft: [], 21487 alignRight: [], 21488 right: [], 21489 left: [], 21490 bottom: [], 21491 top: [] 21492 }; 21493 var getInlineDialogAnchor = function (contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor) { 21494 var bubble = nu$8(-12, 12, bubbleAlignments); 21495 var overrides = { maxHeightFunction: expandable() }; 21496 var editableAreaAnchor = function () { 21497 return { 21498 anchor: 'node', 21499 root: getContentContainer(contentAreaElement()), 21500 node: Optional.from(contentAreaElement()), 21501 bubble: bubble, 21502 layouts: { 21503 onRtl: function () { 21504 return [northwest$3]; 21505 }, 21506 onLtr: function () { 21507 return [northeast$3]; 21508 } 21509 }, 21510 overrides: overrides 21511 }; 21512 }; 21513 var standardAnchor = function () { 21514 return { 21515 anchor: 'hotspot', 21516 hotspot: lazyAnchorbar(), 21517 bubble: bubble, 21518 layouts: { 21519 onRtl: function () { 21520 return [southeast$1]; 21521 }, 21522 onLtr: function () { 21523 return [southwest$1]; 21524 } 21525 }, 21526 overrides: overrides 21527 }; 21528 }; 21529 return function () { 21530 return lazyUseEditableAreaAnchor() ? editableAreaAnchor() : standardAnchor(); 21531 }; 21532 }; 21533 var getBannerAnchor = function (contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor) { 21534 var editableAreaAnchor = function () { 21535 return { 21536 anchor: 'node', 21537 root: getContentContainer(contentAreaElement()), 21538 node: Optional.from(contentAreaElement()), 21539 layouts: { 21540 onRtl: function () { 21541 return [north$3]; 21542 }, 21543 onLtr: function () { 21544 return [north$3]; 21545 } 21546 } 21547 }; 21548 }; 21549 var standardAnchor = function () { 21550 return { 21551 anchor: 'hotspot', 21552 hotspot: lazyAnchorbar(), 21553 layouts: { 21554 onRtl: function () { 21555 return [south$1]; 21556 }, 21557 onLtr: function () { 21558 return [south$1]; 21559 } 21560 } 21561 }; 21562 }; 21563 return function () { 21564 return lazyUseEditableAreaAnchor() ? editableAreaAnchor() : standardAnchor(); 21565 }; 21566 }; 21567 var getCursorAnchor = function (editor, bodyElement) { 21568 return function () { 21569 return { 21570 anchor: 'selection', 21571 root: bodyElement(), 21572 getSelection: function () { 21573 var rng = editor.selection.getRng(); 21574 return Optional.some(SimSelection.range(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset)); 21575 } 21576 }; 21577 }; 21578 }; 21579 var getNodeAnchor = function (bodyElement) { 21580 return function (element) { 21581 return { 21582 anchor: 'node', 21583 root: bodyElement(), 21584 node: element 21585 }; 21586 }; 21587 }; 21588 var getAnchors = function (editor, lazyAnchorbar, isToolbarTop) { 21589 var useFixedToolbarContainer = useFixedContainer(editor); 21590 var bodyElement = function () { 21591 return SugarElement.fromDom(editor.getBody()); 21592 }; 21593 var contentAreaElement = function () { 21594 return SugarElement.fromDom(editor.getContentAreaContainer()); 21595 }; 21596 var lazyUseEditableAreaAnchor = function () { 21597 return useFixedToolbarContainer || !isToolbarTop(); 21598 }; 21599 return { 21600 inlineDialog: getInlineDialogAnchor(contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor),
21601 banner: getBannerAnchor(contentAreaElement, lazyAnchorbar, lazyUseEditableAreaAnchor), 21602 cursor: getCursorAnchor(editor, bodyElement), 21603 node: getNodeAnchor(bodyElement) 21604 }; 21605 }; 21606 21607 var colorPicker = function (editor) { 21608 return function (callback, value) { 21609 var dialog = colorPickerDialog(editor); 21610 dialog(callback, value); 21611 }; 21612 }; 21613 var hasCustomColors$1 = function (editor) { 21614 return function () { 21615 return hasCustomColors(editor); 21616 }; 21617 }; 21618 var getColors$2 = function (editor) { 21619 return function () { 21620 return getColors(editor); 21621 }; 21622 }; 21623 var getColorCols$2 = function (editor) { 21624 return function () { 21625 return getColorCols$1(editor); 21626 }; 21627 }; 21628 var ColorInputBackstage = function (editor) { 21629 return { 21630 colorPicker: colorPicker(editor), 21631 hasCustomColors: hasCustomColors$1(editor), 21632 getColors: getColors$2(editor), 21633 getColorCols: getColorCols$2(editor) 21634 }; 21635 }; 21636 21637 var isDraggableModal$1 = function (editor) { 21638 return function () { 21639 return isDraggableModal(editor); 21640 }; 21641 }; 21642 var DialogBackstage = function (editor) { 21643 return { isDraggableModal: isDraggableModal$1(editor) }; 21644 }; 21645 21646 var HeaderBackstage = function (editor) { 21647 var mode = Cell(isToolbarLocationBottom(editor) ? 'bottom' : 'top'); 21648 return { 21649 isPositionedAtTop: function () { 21650 return mode.get() === 'top'; 21651 }, 21652 getDockingMode: mode.get, 21653 setDockingMode: mode.set 21654 }; 21655 }; 21656 21657 var defaultStyleFormats = [ 21658 { 21659 title: 'Headings', 21660 items: [ 21661 { 21662 title: 'Heading 1', 21663 format: 'h1' 21664 }, 21665 { 21666 title: 'Heading 2', 21667 format: 'h2' 21668 }, 21669 { 21670 title: 'Heading 3', 21671 format: 'h3' 21672 }, 21673 { 21674 title: 'Heading 4', 21675 format: 'h4' 21676 }, 21677 { 21678 title: 'Heading 5', 21679 format: 'h5' 21680 }, 21681 { 21682 title: 'Heading 6', 21683 format: 'h6' 21684 } 21685 ] 21686 }, 21687 { 21688 title: 'Inline', 21689 items: [ 21690 { 21691 title: 'Bold', 21692 format: 'bold' 21693 }, 21694 { 21695 title: 'Italic', 21696 format: 'italic' 21697 }, 21698 { 21699 title: 'Underline', 21700 format: 'underline' 21701 }, 21702 { 21703 title: 'Strikethrough', 21704 format: 'strikethrough' 21705 }, 21706 { 21707 title: 'Superscript', 21708 format: 'superscript' 21709 }, 21710 { 21711 title: 'Subscript', 21712 format: 'subscript' 21713 }, 21714 { 21715 title: 'Code', 21716 format: 'code' 21717 } 21718 ] 21719 }, 21720 { 21721 title: 'Blocks', 21722 items: [ 21723 { 21724 title: 'Paragraph', 21725 format: 'p' 21726 }, 21727 { 21728 title: 'Blockquote', 21729 format: 'blockquote' 21730 }, 21731 { 21732 title: 'Div', 21733 format: 'div' 21734 }, 21735 { 21736 title: 'Pre', 21737 format: 'pre' 21738 } 21739 ] 21740 }, 21741 { 21742 title: 'Align', 21743 items: [ 21744 { 21745 title: 'Left', 21746 format: 'alignleft' 21747 }, 21748 { 21749 title: 'Center', 21750 format: 'aligncenter' 21751 }, 21752 { 21753 title: 'Right', 21754 format: 'alignright' 21755 }, 21756 { 21757 title: 'Justify', 21758 format: 'alignjustify' 21759 } 21760 ] 21761 } 21762 ]; 21763 var isNestedFormat = function (format) { 21764 return has(format, 'items'); 21765 }; 21766 var isBlockFormat = function (format) { 21767 return has(format, 'block'); 21768 }; 21769 var isInlineFormat = function (format) { 21770 return has(format, 'inline'); 21771 }; 21772 var isSelectorFormat = function (format) { 21773 return has(format, 'selector'); 21774 }; 21775 var mapFormats = function (userFormats) { 21776 return foldl(userFormats, function (acc, fmt) { 21777 if (isNestedFormat(fmt)) { 21778 var result = mapFormats(fmt.items); 21779 return { 21780 customFormats: acc.customFormats.concat(result.customFormats), 21781 formats: acc.formats.concat([{ 21782 title: fmt.title, 21783 items: result.formats 21784 }]) 21785 }; 21786 } else if (isInlineFormat(fmt) || isBlockFormat(fmt) || isSelectorFormat(fmt)) { 21787 var formatName = isString(fmt.name) ? fmt.name : fmt.title.toLowerCase(); 21788 var formatNameWithPrefix = 'custom-' + formatName; 21789 return { 21790 customFormats: acc.customFormats.concat([{ 21791 name: formatNameWithPrefix, 21792 format: fmt 21793 }]), 21794 formats: acc.formats.concat([{ 21795 title: fmt.title, 21796 format: formatNameWithPrefix, 21797 icon: fmt.icon 21798 }]) 21799 }; 21800 } else { 21801 return __assign(__assign({}, acc), { formats: acc.formats.concat(fmt) }); 21802 } 21803 }, { 21804 customFormats: [], 21805 formats: [] 21806 }); 21807 }; 21808 var registerCustomFormats = function (editor, userFormats) { 21809 var result = mapFormats(userFormats); 21810 var registerFormats = function (customFormats) { 21811 each(customFormats, function (fmt) { 21812 if (!editor.formatter.has(fmt.name)) { 21813 editor.formatter.register(fmt.name, fmt.format); 21814 } 21815 }); 21816 }; 21817 if (editor.formatter) { 21818 registerFormats(result.customFormats); 21819 } else { 21820 editor.on('init', function () { 21821 registerFormats(result.customFormats); 21822 }); 21823 } 21824 return result.formats; 21825 }; 21826 var getStyleFormats = function (editor) { 21827 return getUserStyleFormats(editor).map(function (userFormats) { 21828 var registeredUserFormats = registerCustomFormats(editor, userFormats); 21829 return isMergeStyleFormats(editor) ? defaultStyleFormats.concat(registeredUserFormats) : registeredUserFormats; 21830 }).getOr(defaultStyleFormats); 21831 }; 21832 21833 var processBasic = function (item, isSelectedFor, getPreviewFor) { 21834 var formatterSpec = { 21835 type: 'formatter', 21836 isSelected: isSelectedFor(item.format), 21837 getStylePreview: getPreviewFor(item.format) 21838 }; 21839 return deepMerge(item, formatterSpec); 21840 }; 21841 var register$3 = function (editor, formats, isSelectedFor, getPreviewFor) { 21842 var enrichSupported = function (item) { 21843 return processBasic(item, isSelectedFor, getPreviewFor); 21844 }; 21845 var enrichMenu = function (item) { 21846 var submenuSpec = { type: 'submenu' }; 21847 return deepMerge(item, submenuSpec); 21848 }; 21849 var enrichCustom = function (item) { 21850 var formatName = isString(item.name) ? item.name : generate$1(item.title); 21851 var formatNameWithPrefix = 'custom-' + formatName; 21852 var customSpec = { 21853 type: 'formatter', 21854 format: formatNameWithPrefix, 21855 isSelected: isSelectedFor(formatNameWithPrefix), 21856 getStylePreview: getPreviewFor(formatNameWithPrefix) 21857 }; 21858 var newItem = deepMerge(item, customSpec); 21859 editor.formatter.register(formatName, newItem); 21860 return newItem; 21861 }; 21862 var doEnrich = function (items) { 21863 return map(items, function (item) { 21864 var keys$1 = keys(item); 21865 if (hasNonNullableKey(item, 'items')) { 21866 var newItems_1 = doEnrich(item.items); 21867 return deepMerge(enrichMenu(item), { 21868 getStyleItems: function () { 21869 return newItems_1; 21870 } 21871 }); 21872 } else if (hasNonNullableKey(item, 'format')) { 21873 return enrichSupported(item); 21874 } else if (keys$1.length === 1 && contains(keys$1, 'title')) { 21875 return deepMerge(item, { type: 'separator' }); 21876 } else { 21877 return enrichCustom(item); 21878 } 21879 }); 21880 }; 21881 return doEnrich(formats); 21882 }; 21883 21884 var init$7 = function (editor) { 21885 var isSelectedFor = function (format) { 21886 return function () { 21887 return editor.formatter.match(format); 21888 }; 21889 }; 21890 var getPreviewFor = function (format) { 21891 return function () { 21892 var fmt = editor.formatter.get(format); 21893 return fmt !== undefined ? Optional.some({ 21894 tag: fmt.length > 0 ? fmt[0].inline || fmt[0].block || 'div' : 'div', 21895 styles: editor.dom.parseStyle(editor.formatter.getCssText(format)) 21896 }) : Optional.none(); 21897 }; 21898 }; 21899 var flatten = function (fmt) { 21900 var subs = fmt.items; 21901 return subs !== undefined && subs.length > 0 ? bind(subs, flatten) : [fmt.format]; 21902 }; 21903 var settingsFormats = Cell([]); 21904 var settingsFlattenedFormats = Cell([]); 21905 var eventsFormats = Cell([]); 21906 var eventsFlattenedFormats = Cell([]); 21907 var replaceSettings = Cell(false); 21908 editor.on('PreInit', function (_e) { 21909 var formats = getStyleFormats(editor); 21910 var enriched = register$3(editor, formats, isSelectedFor, getPreviewFor); 21911 settingsFormats.set(enriched); 21912 settingsFlattenedFormats.set(bind(enriched, flatten)); 21913 }); 21914 editor.on('addStyleModifications', function (e) { 21915 var modifications = register$3(editor, e.items, isSelectedFor, getPreviewFor); 21916 eventsFormats.set(modifications); 21917 replaceSettings.set(e.replace); 21918 eventsFlattenedFormats.set(bind(modifications, flatten)); 21919 }); 21920 var getData = function () { 21921 var fromSettings = replaceSettings.get() ? [] : settingsFormats.get(); 21922 var fromEvents = eventsFormats.get(); 21923 return fromSettings.concat(fromEvents); 21924 }; 21925 var getFlattenedKeys = function () { 21926 var fromSettings = replaceSettings.get() ? [] : settingsFlattenedFormats.get(); 21927 var fromEvents = eventsFlattenedFormats.get(); 21928 return fromSettings.concat(fromEvents); 21929 }; 21930 return { 21931 getData: getData, 21932 getFlattenedKeys: getFlattenedKeys 21933 }; 21934 }; 21935 21936 var isElement$2 = function (node) { 21937 return isNonNullable(node) && node.nodeType === 1; 21938 }; 21939 var trim$1 = global$c.trim; 21940 var hasContentEditableState = function (value) { 21941 return function (node) { 21942 if (isElement$2(node)) { 21943 if (node.contentEditable === value) { 21944 return true; 21945 } 21946 if (node.getAttribute('data-mce-contenteditable') === value) { 21947 return true; 21948 } 21949 } 21950 return false;
21951 }; 21952 }; 21953 var isContentEditableTrue = hasContentEditableState('true'); 21954 var isContentEditableFalse = hasContentEditableState('false'); 21955 var create$8 = function (type, title, url, level, attach) { 21956 return { 21957 type: type, 21958 title: title, 21959 url: url, 21960 level: level, 21961 attach: attach 21962 }; 21963 }; 21964 var isChildOfContentEditableTrue = function (node) { 21965 while (node = node.parentNode) { 21966 var value = node.contentEditable; 21967 if (value && value !== 'inherit') { 21968 return isContentEditableTrue(node); 21969 } 21970 } 21971 return false; 21972 }; 21973 var select = function (selector, root) { 21974 return map(descendants(SugarElement.fromDom(root), selector), function (element) { 21975 return element.dom; 21976 }); 21977 }; 21978 var getElementText = function (elm) { 21979 return elm.innerText || elm.textContent; 21980 }; 21981 var getOrGenerateId = function (elm) { 21982 return elm.id ? elm.id : generate$1('h'); 21983 }; 21984 var isAnchor = function (elm) { 21985 return elm && elm.nodeName === 'A' && (elm.id || elm.name) !== undefined; 21986 }; 21987 var isValidAnchor = function (elm) { 21988 return isAnchor(elm) && isEditable(elm); 21989 }; 21990 var isHeader = function (elm) { 21991 return elm && /^(H[1-6])$/.test(elm.nodeName); 21992 }; 21993 var isEditable = function (elm) { 21994 return isChildOfContentEditableTrue(elm) && !isContentEditableFalse(elm); 21995 }; 21996 var isValidHeader = function (elm) { 21997 return isHeader(elm) && isEditable(elm); 21998 }; 21999 var getLevel = function (elm) { 22000 return isHeader(elm) ? parseInt(elm.nodeName.substr(1), 10) : 0; 22001 }; 22002 var headerTarget = function (elm) { 22003 var headerId = getOrGenerateId(elm); 22004 var attach = function () { 22005 elm.id = headerId; 22006 }; 22007 return create$8('header', getElementText(elm), '#' + headerId, getLevel(elm), attach); 22008 }; 22009 var anchorTarget = function (elm) { 22010 var anchorId = elm.id || elm.name; 22011 var anchorText = getElementText(elm); 22012 return create$8('anchor', anchorText ? anchorText : '#' + anchorId, '#' + anchorId, 0, noop); 22013 }; 22014 var getHeaderTargets = function (elms) { 22015 return map(filter(elms, isValidHeader), headerTarget); 22016 }; 22017 var getAnchorTargets = function (elms) { 22018 return map(filter(elms, isValidAnchor), anchorTarget); 22019 }; 22020 var getTargetElements = function (elm) { 22021 var elms = select('h1,h2,h3,h4,h5,h6,a:not([href])', elm); 22022 return elms; 22023 }; 22024 var hasTitle = function (target) { 22025 return trim$1(target.title).length > 0; 22026 }; 22027 var find$5 = function (elm) { 22028 var elms = getTargetElements(elm); 22029 return filter(getHeaderTargets(elms).concat(getAnchorTargets(elms)), hasTitle); 22030 }; 22031 var LinkTargets = { find: find$5 }; 22032 22033 var STORAGE_KEY = 'tinymce-url-history'; 22034 var HISTORY_LENGTH = 5; 22035 var isHttpUrl = function (url) { 22036 return isString(url) && /^https?/.test(url); 22037 }; 22038 var isArrayOfUrl = function (a) { 22039 return isArray(a) && a.length <= HISTORY_LENGTH && forall(a, isHttpUrl); 22040 }; 22041 var isRecordOfUrlArray = function (r) { 22042 return isObject(r) && find$1(r, function (value) { 22043 return !isArrayOfUrl(value); 22044 }).isNone(); 22045 }; 22046 var getAllHistory = function () { 22047 var unparsedHistory = global$9.getItem(STORAGE_KEY); 22048 if (unparsedHistory === null) { 22049 return {}; 22050 } 22051 var history; 22052 try { 22053 history = JSON.parse(unparsedHistory); 22054 } catch (e) { 22055 if (e instanceof SyntaxError) { 22056 console.log('Local storage ' + STORAGE_KEY + ' was not valid JSON', e); 22057 return {}; 22058 } 22059 throw e; 22060 } 22061 if (!isRecordOfUrlArray(history)) { 22062 console.log('Local storage ' + STORAGE_KEY + ' was not valid format', history); 22063 return {}; 22064 } 22065 return history; 22066 }; 22067 var setAllHistory = function (history) { 22068 if (!isRecordOfUrlArray(history)) { 22069 throw new Error('Bad format for history:\n' + JSON.stringify(history)); 22070 }
22071 global$9.setItem(STORAGE_KEY, JSON.stringify(history)); 22072 }; 22073 var getHistory = function (fileType) { 22074 var history = getAllHistory(); 22075 return Object.prototype.hasOwnProperty.call(history, fileType) ? history[fileType] : []; 22076 }; 22077 var addToHistory = function (url, fileType) { 22078 if (!isHttpUrl(url)) { 22079 return; 22080 } 22081 var history = getAllHistory(); 22082 var items = Object.prototype.hasOwnProperty.call(history, fileType) ? history[fileType] : []; 22083 var itemsWithoutUrl = filter(items, function (item) { 22084 return item !== url; 22085 }); 22086 history[fileType] = [url].concat(itemsWithoutUrl).slice(0, HISTORY_LENGTH); 22087 setAllHistory(history); 22088 }; 22089 22090 var isTruthy = function (value) { 22091 return !!value; 22092 }; 22093 var makeMap = function (value) { 22094 return map$2(global$c.makeMap(value, /[, ]/), isTruthy); 22095 }; 22096 var getPicker = function (editor) { 22097 return Optional.from(getFilePickerCallback(editor)).filter(isFunction); 22098 }; 22099 var getPickerTypes = function (editor) { 22100 var optFileTypes = Optional.some(getFilePickerTypes(editor)).filter(isTruthy); 22101 var optLegacyTypes = Optional.some(getFileBrowserCallbackTypes(editor)).filter(isTruthy); 22102 var optTypes = optFileTypes.or(optLegacyTypes).map(makeMap); 22103 return getPicker(editor).fold(never, function (_picker) { 22104 return optTypes.fold(always, function (types) { 22105 return keys(types).length > 0 ? types : false; 22106 }); 22107 }); 22108 }; 22109 var getPickerSetting = function (editor, filetype) { 22110 var pickerTypes = getPickerTypes(editor); 22111 if (isBoolean(pickerTypes)) { 22112 return pickerTypes ? getPicker(editor) : Optional.none(); 22113 } else { 22114 return pickerTypes[filetype] ? getPicker(editor) : Optional.none(); 22115 } 22116 }; 22117 var getUrlPicker = function (editor, filetype) { 22118 return getPickerSetting(editor, filetype).map(function (picker) { 22119 return function (entry) { 22120 return Future.nu(function (completer) { 22121 var handler = function (value, meta) { 22122 if (!isString(value)) { 22123 throw new Error('Expected value to be string'); 22124 } 22125 if (meta !== undefined && !isObject(meta)) { 22126 throw new Error('Expected meta to be a object'); 22127 } 22128 var r = { 22129 value: value, 22130 meta: meta 22131 }; 22132 completer(r); 22133 }; 22134 var meta = __assign({ 22135 filetype: filetype, 22136 fieldname: entry.fieldname
22137 }, Optional.from(entry.meta).getOr({})); 22138 picker.call(editor, handler, entry.value, meta); 22139 }); 22140 }; 22141 }); 22142 }; 22143 var getTextSetting = function (value) { 22144 return Optional.from(value).filter(isString).getOrUndefined(); 22145 }; 22146 var getLinkInformation = function (editor) { 22147 if (noTypeaheadUrls(editor)) { 22148 return Optional.none(); 22149 } 22150 return Optional.some({ 22151 targets: LinkTargets.find(editor.getBody()), 22152 anchorTop: getTextSetting(getAnchorTop(editor)), 22153 anchorBottom: getTextSetting(getAnchorBottom(editor)) 22154 }); 22155 }; 22156 var getValidationHandler = function (editor) { 22157 return Optional.from(getFilePickerValidatorHandler(editor)); 22158 }; 22159 var UrlInputBackstage = function (editor) { 22160 return { 22161 getHistory: getHistory, 22162 addToHistory: addToHistory, 22163 getLinkInformation: function () { 22164 return getLinkInformation(editor); 22165 }, 22166 getValidationHandler: function () { 22167 return getValidationHandler(editor); 22168 }, 22169 getUrlPicker: function (filetype) { 22170 return getUrlPicker(editor, filetype); 22171 } 22172 }; 22173 }; 22174 22175 var init$8 = function (sink, editor, lazyAnchorbar) { 22176 var contextMenuState = Cell(false); 22177 var toolbar = HeaderBackstage(editor); 22178 var backstage = { 22179 shared: { 22180 providers: { 22181 icons: function () { 22182 return editor.ui.registry.getAll().icons; 22183 }, 22184 menuItems: function () { 22185 return editor.ui.registry.getAll().menuItems; 22186 }, 22187 translate: global$6.translate, 22188 isDisabled: function () { 22189 return editor.mode.isReadOnly() || editor.ui.isDisabled(); 22190 }, 22191 getSetting: editor.getParam.bind(editor) 22192 }, 22193 interpreter: function (s) { 22194 return interpretWithoutForm(s, backstage); 22195 }, 22196 anchors: getAnchors(editor, lazyAnchorbar, toolbar.isPositionedAtTop), 22197 header: toolbar, 22198 getSink: function () { 22199 return Result.value(sink); 22200 } 22201 }, 22202 urlinput: UrlInputBackstage(editor), 22203 styleselect: init$7(editor), 22204 colorinput: ColorInputBackstage(editor), 22205 dialog: DialogBackstage(editor), 22206 isContextMenuOpen: function () { 22207 return contextMenuState.get(); 22208 }, 22209 setContextMenuState: function (state) { 22210 return contextMenuState.set(state); 22211 } 22212 }; 22213 return backstage; 22214 }; 22215 22216 var expandable$1 = constant(function (element, available) { 22217 setMax$1(element, Math.floor(available)); 22218 }); 22219 22220 var showContextToolbarEvent = 'contexttoolbar-show'; 22221 var hideContextToolbarEvent = 'contexttoolbar-hide'; 22222 22223 var schema$k = constant([ 22224 strict$1('dom'), 22225 defaulted$1('shell', true), 22226 field$1('toolbarBehaviours', [Replacing]) 22227 ]); 22228 var enhanceGroups = function () { 22229 return { behaviours: derive$1([Replacing.config({})]) }; 22230 }; 22231 var parts$7 = constant([optional({ 22232 name: 'groups', 22233 overrides: enhanceGroups 22234 })]); 22235 22236 var factory$9 = function (detail, components, _spec, _externals) { 22237 var setGroups = function (toolbar, groups) { 22238 getGroupContainer(toolbar).fold(function () { 22239 console.error('Toolbar was defined to not be a shell, but no groups container was specified in components'); 22240 throw new Error('Toolbar was defined to not be a shell, but no groups container was specified in components'); 22241 }, function (container) { 22242 Replacing.set(container, groups); 22243 }); 22244 }; 22245 var getGroupContainer = function (component) { 22246 return detail.shell ? Optional.some(component) : getPart(component, detail, 'groups'); 22247 }; 22248 var extra = detail.shell ? { 22249 behaviours: [Replacing.config({})], 22250 components: [] 22251 } : { 22252 behaviours: [], 22253 components: components 22254 }; 22255 return { 22256 uid: detail.uid, 22257 dom: detail.dom, 22258 components: extra.components, 22259 behaviours: augment(detail.toolbarBehaviours, extra.behaviours), 22260 apis: { setGroups: setGroups }, 22261 domModification: { attributes: { role: 'group' } } 22262 }; 22263 }; 22264 var Toolbar = composite$1({ 22265 name: 'Toolbar', 22266 configFields: schema$k(), 22267 partFields: parts$7(), 22268 factory: factory$9, 22269 apis: { 22270 setGroups: function (apis, toolbar, groups) { 22271 apis.setGroups(toolbar, groups); 22272 } 22273 } 22274 }); 22275 22276 var generate$6 = function (xs, f) { 22277 var init = { 22278 len: 0, 22279 list: [] 22280 }; 22281 var r = foldl(xs, function (b, a) { 22282 var value = f(a, b.len); 22283 return value.fold(constant(b), function (v) { 22284 return { 22285 len: v.finish, 22286 list: b.list.concat([v]) 22287 }; 22288 }); 22289 }, init); 22290 return r.list; 22291 }; 22292 22293 var output$1 = function (within, extra, withinWidth) { 22294 return { 22295 within: within, 22296 extra: extra, 22297 withinWidth: withinWidth 22298 }; 22299 };
22300 var apportion = function (units, total, len) { 22301 var parray = generate$6(units, function (unit, current) { 22302 var width = len(unit); 22303 return Optional.some({ 22304 element: unit, 22305 start: current, 22306 finish: current + width, 22307 width: width 22308 }); 22309 }); 22310 var within = filter(parray, function (unit) { 22311 return unit.finish <= total; 22312 }); 22313 var withinWidth = foldr(within, function (acc, el) { 22314 return acc + el.width; 22315 }, 0); 22316 var extra = parray.slice(within.length); 22317 return { 22318 within: within, 22319 extra: extra, 22320 withinWidth: withinWidth 22321 }; 22322 }; 22323 var toUnit = function (parray) { 22324 return map(parray, function (unit) { 22325 return unit.element; 22326 }); 22327 }; 22328 var fitLast = function (within, extra, withinWidth) { 22329 var fits = toUnit(within.concat(extra)); 22330 return output$1(fits, [], withinWidth); 22331 }; 22332 var overflow = function (within, extra, overflower, withinWidth) { 22333 var fits = toUnit(within).concat([overflower]); 22334 return output$1(fits, toUnit(extra), withinWidth); 22335 }; 22336 var fitAll = function (within, extra, withinWidth) { 22337 return output$1(toUnit(within), [], withinWidth); 22338 }; 22339 var tryFit = function (total, units, len) { 22340 var divide = apportion(units, total, len); 22341 return divide.extra.length === 0 ? Optional.some(divide) : Optional.none(); 22342 }; 22343 var partition$3 = function (total, units, len, overflower) { 22344 var divide = tryFit(total, units, len).getOrThunk(function () { 22345 return apportion(units, total - len(overflower), len); 22346 }); 22347 var within = divide.within; 22348 var extra = divide.extra; 22349 var withinWidth = divide.withinWidth; 22350 if (extra.length === 1 && extra[0].width <= len(overflower)) { 22351 return fitLast(within, extra, withinWidth); 22352 } else if (extra.length >= 1) { 22353 return overflow(within, extra, overflower, withinWidth); 22354 } else { 22355 return fitAll(within, extra, withinWidth); 22356 } 22357 }; 22358 22359 var setGroups = function (toolbar, storedGroups) { 22360 var bGroups = map(storedGroups, function (g) { 22361 return premade$1(g); 22362 }); 22363 Toolbar.setGroups(toolbar, bGroups); 22364 }; 22365 var findFocusedComp = function (comps) { 22366 return findMap(comps, function (comp) { 22367 return search(comp.element).bind(function (focusedElm) { 22368 return comp.getSystem().getByDom(focusedElm).toOptional(); 22369 }); 22370 }); 22371 }; 22372 var refresh = function (toolbar, detail, setOverflow) { 22373 var primary = getPartOrDie(toolbar, detail, 'primary'); 22374 var overflowGroup = Coupling.getCoupled(toolbar, 'overflowGroup'); 22375 set$2(primary.element, 'visibility', 'hidden'); 22376 var groups = detail.builtGroups.get().concat([overflowGroup]); 22377 var focusedComp = findFocusedComp(groups); 22378 setOverflow([]); 22379 setGroups(primary, groups); 22380 var availableWidth = get$8(primary.element); 22381 var overflows = partition$3(availableWidth, detail.builtGroups.get(), function (comp) { 22382 return get$8(comp.element); 22383 }, overflowGroup); 22384 if (overflows.extra.length === 0) { 22385 Replacing.remove(primary, overflowGroup); 22386 setOverflow([]); 22387 } else { 22388 setGroups(primary, overflows.within); 22389 setOverflow(overflows.extra); 22390 } 22391 remove$6(primary.element, 'visibility'); 22392 reflow(primary.element); 22393 focusedComp.each(Focusing.focus); 22394 }; 22395 22396 var schema$l = constant([ 22397 field$1('splitToolbarBehaviours', [Coupling]), 22398 state$1('builtGroups', function () { 22399 return Cell([]); 22400 }) 22401 ]); 22402 22403 var schema$m = constant([ 22404 markers(['overflowToggledClass']), 22405 optionFunction('getOverflowBounds'), 22406 strict$1('lazySink'), 22407 state$1('overflowGroups', function () { 22408 return Cell([]); 22409 }) 22410 ].concat(schema$l())); 22411 var parts$8 = constant([ 22412 required({ 22413 factory: Toolbar, 22414 schema: schema$k(), 22415 name: 'primary' 22416 }), 22417 external$1({ 22418 schema: schema$k(), 22419 name: 'overflow' 22420 }), 22421 external$1({ name: 'overflow-button' }), 22422 external$1({ name: 'overflow-group' }) 22423 ]); 22424 22425 var schema$n = constant([ 22426 markers(['toggledClass']),
22427 strict$1('lazySink'), 22428 strictFunction('fetch'), 22429 optionFunction('getBounds'), 22430 optionObjOf('fireDismissalEventInstead', [defaulted$1('event', dismissRequested())]), 22431 schema$1() 22432 ]); 22433 var parts$9 = constant([ 22434 external$1({ 22435 name: 'button', 22436 overrides: function (detail) { 22437 return { 22438 dom: { attributes: { 'aria-haspopup': 'true' } }, 22439 buttonBehaviours: derive$1([Toggling.config({ 22440 toggleClass: detail.markers.toggledClass, 22441 aria: { mode: 'expanded' }, 22442 toggleOnExecute: false 22443 })]) 22444 }; 22445 } 22446 }), 22447 external$1({ 22448 factory: Toolbar, 22449 schema: schema$k(), 22450 name: 'toolbar', 22451 overrides: function (detail) { 22452 return { 22453 toolbarBehaviours: derive$1([Keying.config({ 22454 mode: 'cyclic', 22455 onEscape: function (comp) { 22456 getPart(comp, detail, 'button').each(Focusing.focus); 22457 return Optional.none(); 22458 } 22459 })]) 22460 }; 22461 } 22462 }) 22463 ]); 22464 22465 var toggle$2 = function (button, externals) { 22466 var toolbarSandbox = Coupling.getCoupled(button, 'toolbarSandbox'); 22467 if (Sandboxing.isOpen(toolbarSandbox)) { 22468 Sandboxing.close(toolbarSandbox); 22469 } else { 22470 Sandboxing.open(toolbarSandbox, externals.toolbar()); 22471 } 22472 }; 22473 var position$2 = function (button, toolbar, detail, layouts) { 22474 var bounds = detail.getBounds.map(function (bounder) { 22475 return bounder(); 22476 }); 22477 var sink = detail.lazySink(button).getOrDie(); 22478 Positioning.positionWithinBounds(sink, { 22479 anchor: 'hotspot', 22480 hotspot: button, 22481 layouts: layouts, 22482 overrides: { maxWidthFunction: expandable$1() } 22483 }, toolbar, bounds); 22484 }; 22485 var setGroups$1 = function (button, toolbar, detail, layouts, groups) { 22486 Toolbar.setGroups(toolbar, groups); 22487 position$2(button, toolbar, detail, layouts); 22488 Toggling.on(button); 22489 }; 22490 var makeSandbox$1 = function (button, spec, detail) { 22491 var ariaOwner = manager(); 22492 var onOpen = function (sandbox, toolbar) { 22493 detail.fetch().get(function (groups) { 22494 setGroups$1(button, toolbar, detail, spec.layouts, groups); 22495 ariaOwner.link(button.element); 22496 Keying.focusIn(toolbar); 22497 }); 22498 }; 22499 var onClose = function () { 22500 Toggling.off(button); 22501 Focusing.focus(button); 22502 ariaOwner.unlink(button.element); 22503 }; 22504 return { 22505 dom: { 22506 tag: 'div', 22507 attributes: { id: ariaOwner.id } 22508 }, 22509 behaviours: derive$1([ 22510 Keying.config({ 22511 mode: 'special', 22512 onEscape: function (comp) { 22513 Sandboxing.close(comp); 22514 return Optional.some(true); 22515 } 22516 }), 22517 Sandboxing.config({ 22518 onOpen: onOpen, 22519 onClose: onClose, 22520 isPartOf: function (container, data, queryElem) { 22521 return isPartOf(data, queryElem) || isPartOf(button, queryElem); 22522 }, 22523 getAttachPoint: function () { 22524 return detail.lazySink(button).getOrDie(); 22525 } 22526 }), 22527 Receiving.config({ 22528 channels: __assign(__assign({}, receivingChannel(__assign({ isExtraPart: never }, detail.fireDismissalEventInstead.map(function (fe) { 22529 return { fireEventInstead: { event: fe.event } }; 22530 }).getOr({})))), receivingChannel$1({ 22531 doReposition: function () { 22532 Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox')).each(function (toolbar) { 22533 position$2(button, toolbar, detail, spec.layouts); 22534 }); 22535 } 22536 })) 22537 }) 22538 ]) 22539 }; 22540 }; 22541 var factory$a = function (detail, components, spec, externals) { 22542 return __assign(__assign({}, Button.sketch(__assign(__assign({}, externals.button()), { 22543 action: function (button) { 22544 toggle$2(button, externals); 22545 }, 22546 buttonBehaviours: SketchBehaviours.augment({ dump: externals.button().buttonBehaviours }, [Coupling.config({ 22547 others: { 22548 toolbarSandbox: function (button) { 22549 return makeSandbox$1(button, spec, detail); 22550 } 22551 } 22552 })]) 22553 }))), { 22554 apis: { 22555 setGroups: function (button, groups) { 22556 Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox')).each(function (toolbar) { 22557 setGroups$1(button, toolbar, detail, spec.layouts, groups); 22558 }); 22559 }, 22560 reposition: function (button) { 22561 Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox')).each(function (toolbar) { 22562 position$2(button, toolbar, detail, spec.layouts); 22563 }); 22564 }, 22565 toggle: function (button) { 22566 toggle$2(button, externals); 22567 }, 22568 getToolbar: function (button) { 22569 return Sandboxing.getState(Coupling.getCoupled(button, 'toolbarSandbox')); 22570 }, 22571 isOpen: function (button) { 22572 return Sandboxing.isOpen(Coupling.getCoupled(button, 'toolbarSandbox')); 22573 } 22574 } 22575 }); 22576 }; 22577 var FloatingToolbarButton = composite$1({ 22578 name: 'FloatingToolbarButton', 22579 factory: factory$a, 22580 configFields: schema$n(), 22581 partFields: parts$9(), 22582 apis: { 22583 setGroups: function (apis, button, groups) { 22584 apis.setGroups(button, groups); 22585 }, 22586 reposition: function (apis, button) { 22587 apis.reposition(button); 22588 }, 22589 toggle: function (apis, button) { 22590 apis.toggle(button); 22591 }, 22592 getToolbar: function (apis, button) { 22593 return apis.getToolbar(button); 22594 }, 22595 isOpen: function (apis, button) { 22596 return apis.isOpen(button); 22597 } 22598 } 22599 }); 22600 22601 var schema$o = constant([
22602 strict$1('items'), 22603 markers(['itemSelector']), 22604 field$1('tgroupBehaviours', [Keying]) 22605 ]); 22606 var parts$a = constant([group({ 22607 name: 'items', 22608 unit: 'item' 22609 })]); 22610 22611 var factory$b = function (detail, components, _spec, _externals) { 22612 return { 22613 uid: detail.uid, 22614 dom: detail.dom, 22615 components: components, 22616 behaviours: augment(detail.tgroupBehaviours, [Keying.config({ 22617 mode: 'flow', 22618 selector: detail.markers.itemSelector 22619 })]), 22620 domModification: { attributes: { role: 'toolbar' } } 22621 }; 22622 }; 22623 var ToolbarGroup = composite$1({ 22624 name: 'ToolbarGroup', 22625 configFields: schema$o(), 22626 partFields: parts$a(), 22627 factory: factory$b 22628 }); 22629 22630 var buildGroups = function (comps) { 22631 return map(comps, function (g) { 22632 return premade$1(g); 22633 }); 22634 }; 22635 var refresh$1 = function (toolbar, memFloatingToolbarButton, detail) { 22636 refresh(toolbar, detail, function (overflowGroups) { 22637 detail.overflowGroups.set(overflowGroups); 22638 memFloatingToolbarButton.getOpt(toolbar).each(function (floatingToolbarButton) { 22639 FloatingToolbarButton.setGroups(floatingToolbarButton, buildGroups(overflowGroups)); 22640 }); 22641 }); 22642 }; 22643 var factory$c = function (detail, components, spec, externals) { 22644 var memFloatingToolbarButton = record(FloatingToolbarButton.sketch({ 22645 fetch: function () { 22646 return Future.nu(function (resolve) { 22647 resolve(buildGroups(detail.overflowGroups.get())); 22648 }); 22649 }, 22650 layouts: { 22651 onLtr: function () { 22652 return [ 22653 southwest$1, 22654 southeast$1 22655 ]; 22656 }, 22657 onRtl: function () { 22658 return [ 22659 southeast$1, 22660 southwest$1 22661 ]; 22662 }, 22663 onBottomLtr: function () { 22664 return [ 22665 northwest$1, 22666 northeast$1 22667 ]; 22668 }, 22669 onBottomRtl: function () { 22670 return [ 22671 northeast$1, 22672 northwest$1 22673 ]; 22674 } 22675 }, 22676 getBounds: spec.getOverflowBounds, 22677 lazySink: detail.lazySink, 22678 fireDismissalEventInstead: {}, 22679 markers: { toggledClass: detail.markers.overflowToggledClass }, 22680 parts: { 22681 button: externals['overflow-button'](), 22682 toolbar: externals.overflow() 22683 } 22684 })); 22685 return { 22686 uid: detail.uid, 22687 dom: detail.dom, 22688 components: components, 22689 behaviours: augment(detail.splitToolbarBehaviours, [Coupling.config({ 22690 others: { 22691 overflowGroup: function () { 22692 return ToolbarGroup.sketch(__assign(__assign({}, externals['overflow-group']()), { items: [memFloatingToolbarButton.asSpec()] })); 22693 } 22694 } 22695 })]), 22696 apis: { 22697 setGroups: function (toolbar, groups) { 22698 detail.builtGroups.set(map(groups, toolbar.getSystem().build)); 22699 refresh$1(toolbar, memFloatingToolbarButton, detail); 22700 }, 22701 refresh: function (toolbar) { 22702 return refresh$1(toolbar, memFloatingToolbarButton, detail); 22703 }, 22704 toggle: function (toolbar) { 22705 memFloatingToolbarButton.getOpt(toolbar).each(function (floatingToolbarButton) { 22706 FloatingToolbarButton.toggle(floatingToolbarButton); 22707 }); 22708 }, 22709 isOpen: function (toolbar) { 22710 return memFloatingToolbarButton.getOpt(toolbar).map(FloatingToolbarButton.isOpen).getOr(false); 22711 }, 22712 reposition: function (toolbar) { 22713 memFloatingToolbarButton.getOpt(toolbar).each(function (floatingToolbarButton) { 22714 FloatingToolbarButton.reposition(floatingToolbarButton); 22715 }); 22716 }, 22717 getOverflow: function (toolbar) { 22718 return memFloatingToolbarButton.getOpt(toolbar).bind(FloatingToolbarButton.getToolbar); 22719 } 22720 }, 22721 domModification: { attributes: { role: 'group' } } 22722 }; 22723 }; 22724 var SplitFloatingToolbar = composite$1({ 22725 name: 'SplitFloatingToolbar', 22726 configFields: schema$m(), 22727 partFields: parts$8(), 22728 factory: factory$c, 22729 apis: { 22730 setGroups: function (apis, toolbar, groups) { 22731 apis.setGroups(toolbar, groups); 22732 }, 22733 refresh: function (apis, toolbar) { 22734 apis.refresh(toolbar); 22735 }, 22736 reposition: function (apis, toolbar) { 22737 apis.reposition(toolbar); 22738 }, 22739 toggle: function (apis, toolbar) { 22740 apis.toggle(toolbar); 22741 }, 22742 isOpen: function (apis, toolbar) { 22743 return apis.isOpen(toolbar); 22744 }, 22745 getOverflow: function (apis, toolbar) { 22746 return apis.getOverflow(toolbar); 22747 } 22748 } 22749 }); 22750 22751 var getAnimationRoot = function (component, slideConfig) { 22752 return slideConfig.getAnimationRoot.fold(function () { 22753 return component.element; 22754 }, function (get) { 22755 return get(component); 22756 }); 22757 }; 22758 22759 var getDimensionProperty = function (slideConfig) { 22760 return slideConfig.dimension.property; 22761 }; 22762 var getDimension = function (slideConfig, elem) { 22763 return slideConfig.dimension.getDimension(elem); 22764 }; 22765 var disableTransitions = function (component, slideConfig) { 22766 var root = getAnimationRoot(component, slideConfig); 22767 remove$5(root, [ 22768 slideConfig.shrinkingClass, 22769 slideConfig.growingClass 22770 ]); 22771 }; 22772 var setShrunk = function (component, slideConfig) { 22773 remove$4(component.element, slideConfig.openClass); 22774 add$2(component.element, slideConfig.closedClass); 22775 set$2(component.element, getDimensionProperty(slideConfig), '0px'); 22776 reflow(component.element); 22777 }; 22778 var setGrown = function (component, slideConfig) { 22779 remove$4(component.element, slideConfig.closedClass); 22780 add$2(component.element, slideConfig.openClass); 22781 remove$6(component.element, getDimensionProperty(slideConfig)); 22782 }; 22783 var doImmediateShrink = function (component, slideConfig, slideState, _calculatedSize) { 22784 slideState.setCollapsed(); 22785 set$2(component.element, getDimensionProperty(slideConfig), getDimension(slideConfig, component.element)); 22786 reflow(component.element); 22787 disableTransitions(component, slideConfig); 22788 setShrunk(component, slideConfig);
22789 slideConfig.onStartShrink(component); 22790 slideConfig.onShrunk(component); 22791 }; 22792 var doStartShrink = function (component, slideConfig, slideState, calculatedSize) { 22793 var size = calculatedSize.getOrThunk(function () { 22794 return getDimension(slideConfig, component.element); 22795 }); 22796 slideState.setCollapsed(); 22797 set$2(component.element, getDimensionProperty(slideConfig), size); 22798 reflow(component.element); 22799 var root = getAnimationRoot(component, slideConfig); 22800 remove$4(root, slideConfig.growingClass); 22801 add$2(root, slideConfig.shrinkingClass); 22802 setShrunk(component, slideConfig); 22803 slideConfig.onStartShrink(component); 22804 }; 22805 var doStartSmartShrink = function (component, slideConfig, slideState) { 22806 var size = getDimension(slideConfig, component.element); 22807 var shrinker = size === '0px' ? doImmediateShrink : doStartShrink; 22808 shrinker(component, slideConfig, slideState, Optional.some(size)); 22809 }; 22810 var doStartGrow = function (component, slideConfig, slideState) { 22811 var root = getAnimationRoot(component, slideConfig); 22812 var wasShrinking = has$2(root, slideConfig.shrinkingClass); 22813 var beforeSize = getDimension(slideConfig, component.element); 22814 setGrown(component, slideConfig); 22815 var fullSize = getDimension(slideConfig, component.element); 22816 var startPartialGrow = function () { 22817 set$2(component.element, getDimensionProperty(slideConfig), beforeSize); 22818 reflow(component.element); 22819 }; 22820 var startCompleteGrow = function () { 22821 setShrunk(component, slideConfig); 22822 }; 22823 var setStartSize = wasShrinking ? startPartialGrow : startCompleteGrow; 22824 setStartSize(); 22825 remove$4(root, slideConfig.shrinkingClass); 22826 add$2(root, slideConfig.growingClass); 22827 setGrown(component, slideConfig); 22828 set$2(component.element, getDimensionProperty(slideConfig), fullSize); 22829 slideState.setExpanded(); 22830 slideConfig.onStartGrow(component); 22831 }; 22832 var refresh$2 = function (component, slideConfig, slideState) { 22833 if (slideState.isExpanded()) { 22834 remove$6(component.element, getDimensionProperty(slideConfig)); 22835 var fullSize = getDimension(slideConfig, component.element); 22836 set$2(component.element, getDimensionProperty(slideConfig), fullSize); 22837 } 22838 }; 22839 var grow = function (component, slideConfig, slideState) { 22840 if (!slideState.isExpanded()) { 22841 doStartGrow(component, slideConfig, slideState); 22842 } 22843 }; 22844 var shrink = function (component, slideConfig, slideState) { 22845 if (slideState.isExpanded()) { 22846 doStartSmartShrink(component, slideConfig, slideState); 22847 } 22848 }; 22849 var immediateShrink = function (component, slideConfig, slideState) { 22850 if (slideState.isExpanded()) { 22851 doImmediateShrink(component, slideConfig, slideState, Optional.none()); 22852 } 22853 }; 22854 var hasGrown = function (component, slideConfig, slideState) { 22855 return slideState.isExpanded(); 22856 }; 22857 var hasShrunk = function (component, slideConfig, slideState) { 22858 return slideState.isCollapsed(); 22859 }; 22860 var isGrowing = function (component, slideConfig, _slideState) { 22861 var root = getAnimationRoot(component, slideConfig); 22862 return has$2(root, slideConfig.growingClass) === true; 22863 }; 22864 var isShrinking = function (component, slideConfig, _slideState) { 22865 var root = getAnimationRoot(component, slideConfig); 22866 return has$2(root, slideConfig.shrinkingClass) === true; 22867 }; 22868 var isTransitioning = function (component, slideConfig, slideState) { 22869 return isGrowing(component, slideConfig) || isShrinking(component, slideConfig); 22870 }; 22871 var toggleGrow = function (component, slideConfig, slideState) { 22872 var f = slideState.isExpanded() ? doStartSmartShrink : doStartGrow; 22873 f(component, slideConfig, slideState); 22874 }; 22875 22876 var SlidingApis = /*#__PURE__*/Object.freeze({ 22877 __proto__: null, 22878 refresh: refresh$2, 22879 grow: grow, 22880 shrink: shrink, 22881 immediateShrink: immediateShrink, 22882 hasGrown: hasGrown, 22883 hasShrunk: hasShrunk, 22884 isGrowing: isGrowing, 22885 isShrinking: isShrinking, 22886 isTransitioning: isTransitioning, 22887 toggleGrow: toggleGrow, 22888 disableTransitions: disableTransitions 22889 }); 22890 22891 var exhibit$6 = function (base, slideConfig, _slideState) { 22892 var expanded = slideConfig.expanded; 22893 return expanded ? nu$6({ 22894 classes: [slideConfig.openClass], 22895 styles: {} 22896 }) : nu$6({ 22897 classes: [slideConfig.closedClass],
22898 styles: wrap$1(slideConfig.dimension.property, '0px') 22899 }); 22900 }; 22901 var events$d = function (slideConfig, slideState) { 22902 return derive([runOnSource(transitionend(), function (component, simulatedEvent) { 22903 var raw = simulatedEvent.event.raw; 22904 if (raw.propertyName === slideConfig.dimension.property) { 22905 disableTransitions(component, slideConfig); 22906 if (slideState.isExpanded()) { 22907 remove$6(component.element, slideConfig.dimension.property); 22908 } 22909 var notify = slideState.isExpanded() ? slideConfig.onGrown : slideConfig.onShrunk; 22910 notify(component); 22911 } 22912 })]); 22913 }; 22914 22915 var ActiveSliding = /*#__PURE__*/Object.freeze({ 22916 __proto__: null, 22917 exhibit: exhibit$6, 22918 events: events$d 22919 }); 22920 22921 var SlidingSchema = [ 22922 strict$1('closedClass'), 22923 strict$1('openClass'), 22924 strict$1('shrinkingClass'), 22925 strict$1('growingClass'), 22926 option('getAnimationRoot'), 22927 onHandler('onShrunk'), 22928 onHandler('onStartShrink'), 22929 onHandler('onGrown'), 22930 onHandler('onStartGrow'), 22931 defaulted$1('expanded', false), 22932 strictOf('dimension', choose$1('property', { 22933 width: [ 22934 output('property', 'width'), 22935 output('getDimension', function (elem) { 22936 return get$8(elem) + 'px'; 22937 }) 22938 ], 22939 height: [ 22940 output('property', 'height'), 22941 output('getDimension', function (elem) { 22942 return get$7(elem) + 'px'; 22943 }) 22944 ] 22945 })) 22946 ]; 22947 22948 var init$9 = function (spec) { 22949 var state = Cell(spec.expanded); 22950 var readState = function () { 22951 return 'expanded: ' + state.get(); 22952 }; 22953 return nu$5({ 22954 isExpanded: function () { 22955 return state.get() === true; 22956 }, 22957 isCollapsed: function () { 22958 return state.get() === false; 22959 }, 22960 setCollapsed: curry(state.set, false), 22961 setExpanded: curry(state.set, true), 22962 readState: readState 22963 }); 22964 }; 22965 22966 var SlidingState = /*#__PURE__*/Object.freeze({ 22967 __proto__: null, 22968 init: init$9 22969 }); 22970 22971 var Sliding = create$1({ 22972 fields: SlidingSchema, 22973 name: 'sliding', 22974 active: ActiveSliding, 22975 apis: SlidingApis, 22976 state: SlidingState 22977 }); 22978 22979 var schema$p = constant([ 22980 markers([ 22981 'closedClass', 22982 'openClass', 22983 'shrinkingClass', 22984 'growingClass', 22985 'overflowToggledClass' 22986 ]), 22987 onHandler('onOpened'), 22988 onHandler('onClosed') 22989 ].concat(schema$l())); 22990 var parts$b = constant([ 22991 required({ 22992 factory: Toolbar, 22993 schema: schema$k(), 22994 name: 'primary' 22995 }), 22996 required({ 22997 factory: Toolbar, 22998 schema: schema$k(), 22999 name: 'overflow', 23000 overrides: function (detail) { 23001 return { 23002 toolbarBehaviours: derive$1([ 23003 Sliding.config({ 23004 dimension: { property: 'height' }, 23005 closedClass: detail.markers.closedClass, 23006 openClass: detail.markers.openClass, 23007 shrinkingClass: detail.markers.shrinkingClass, 23008 growingClass: detail.markers.growingClass, 23009 onShrunk: function (comp) { 23010 getPart(comp, detail, 'overflow-button').each(function (button) { 23011 Toggling.off(button); 23012 Focusing.focus(button); 23013 }); 23014 detail.onClosed(comp); 23015 }, 23016 onGrown: function (comp) { 23017 Keying.focusIn(comp); 23018 detail.onOpened(comp); 23019 }, 23020 onStartGrow: function (comp) { 23021 getPart(comp, detail, 'overflow-button').each(Toggling.on); 23022 } 23023 }), 23024 Keying.config({ 23025 mode: 'acyclic', 23026 onEscape: function (comp) { 23027 getPart(comp, detail, 'overflow-button').each(Focusing.focus); 23028 return Optional.some(true); 23029 } 23030 }) 23031 ]) 23032 }; 23033 } 23034 }), 23035 external$1({ 23036 name: 'overflow-button', 23037 overrides: function (detail) { 23038 return { 23039 buttonBehaviours: derive$1([Toggling.config({ 23040 toggleClass: detail.markers.overflowToggledClass, 23041 aria: { mode: 'pressed' }, 23042 toggleOnExecute: false 23043 })]) 23044 }; 23045 } 23046 }), 23047 external$1({ name: 'overflow-group' }) 23048 ]); 23049 23050 var isOpen$1 = function (toolbar, detail) { 23051 return getPart(toolbar, detail, 'overflow').map(Sliding.hasGrown).getOr(false); 23052 }; 23053 var toggleToolbar = function (toolbar, detail) { 23054 getPart(toolbar, detail, 'overflow-button').bind(function () { 23055 return getPart(toolbar, detail, 'overflow'); 23056 }).each(function (overf) { 23057 refresh$3(toolbar, detail); 23058 Sliding.toggleGrow(overf); 23059 }); 23060 }; 23061 var refresh$3 = function (toolbar, detail) { 23062 getPart(toolbar, detail, 'overflow').each(function (overflow) { 23063 refresh(toolbar, detail, function (groups) { 23064 var builtGroups = map(groups, function (g) { 23065 return premade$1(g); 23066 }); 23067 Toolbar.setGroups(overflow, builtGroups); 23068 }); 23069 getPart(toolbar, detail, 'overflow-button').each(function (button) { 23070 if (Sliding.hasGrown(overflow)) { 23071 Toggling.on(button); 23072 } 23073 }); 23074 Sliding.refresh(overflow); 23075 }); 23076 }; 23077 var factory$d = function (detail, components, spec, externals) { 23078 var toolbarToggleEvent = 'alloy.toolbar.toggle'; 23079 var doSetGroups = function (toolbar, groups) { 23080 var built = map(groups, toolbar.getSystem().build); 23081 detail.builtGroups.set(built); 23082 }; 23083 return { 23084 uid: detail.uid, 23085 dom: detail.dom, 23086 components: components, 23087 behaviours: augment(detail.splitToolbarBehaviours, [ 23088 Coupling.config({ 23089 others: { 23090 overflowGroup: function (toolbar) { 23091 return ToolbarGroup.sketch(__assign(__assign({}, externals['overflow-group']()), { 23092 items: [Button.sketch(__assign(__assign({}, externals['overflow-button']()), { 23093 action: function (_button) { 23094 emit(toolbar, toolbarToggleEvent); 23095 } 23096 }))] 23097 })); 23098 } 23099 } 23100 }), 23101 config('toolbar-toggle-events', [run(toolbarToggleEvent, function (toolbar) { 23102 toggleToolbar(toolbar, detail); 23103 })]) 23104 ]), 23105 apis: { 23106 setGroups: function (toolbar, groups) { 23107 doSetGroups(toolbar, groups); 23108 refresh$3(toolbar, detail); 23109 }, 23110 refresh: function (toolbar) { 23111 return refresh$3(toolbar, detail); 23112 }, 23113 toggle: function (toolbar) { 23114 return toggleToolbar(toolbar, detail); 23115 }, 23116 isOpen: function (toolbar) { 23117 return isOpen$1(toolbar, detail); 23118 } 23119 }, 23120 domModification: { attributes: { role: 'group' } } 23121 }; 23122 }; 23123 var SplitSlidingToolbar = composite$1({ 23124 name: 'SplitSlidingToolbar', 23125 configFields: schema$p(), 23126 partFields: parts$b(), 23127 factory: factory$d, 23128 apis: { 23129 setGroups: function (apis, toolbar, groups) { 23130 apis.setGroups(toolbar, groups); 23131 }, 23132 refresh: function (apis, toolbar) { 23133 apis.refresh(toolbar); 23134 }, 23135 toggle: function (apis, toolbar) { 23136 apis.toggle(toolbar); 23137 }, 23138 isOpen: function (apis, toolbar) { 23139 return apis.isOpen(toolbar); 23140 } 23141 } 23142 }); 23143 23144 var toolbarHeightChange = constant(generate$1('toolbar-height-change')); 23145 23146 var renderToolbarGroupCommon = function (toolbarGroup) { 23147 var attributes = toolbarGroup.title.fold(function () { 23148 return {}; 23149 }, function (title) { 23150 return { attributes: { title: title } }; 23151 }); 23152 return { 23153 dom: __assign({ 23154 tag: 'div', 23155 classes: ['tox-toolbar__group'] 23156 }, attributes), 23157 components: [ToolbarGroup.parts.items({})], 23158 items: toolbarGroup.items, 23159 markers: { itemSelector: '*:not(.tox-split-button) > .tox-tbtn:not([disabled]), ' + '.tox-split-button:not([disabled]), ' + '.tox-toolbar-nav-js:not([disabled])' }, 23160 tgroupBehaviours: derive$1([ 23161 Tabstopping.config({}), 23162 Focusing.config({}) 23163 ]) 23164 }; 23165 }; 23166 var renderToolbarGroup = function (toolbarGroup) { 23167 return ToolbarGroup.sketch(renderToolbarGroupCommon(toolbarGroup)); 23168 }; 23169 var getToolbarbehaviours = function (toolbarSpec, modeName) { 23170 var onAttached = runOnAttached(function (component) { 23171 var groups = map(toolbarSpec.initGroups, renderToolbarGroup); 23172 Toolbar.setGroups(component, groups); 23173 }); 23174 return derive$1([ 23175 DisablingConfigs.toolbarButton(toolbarSpec.providers.isDisabled), 23176 receivingConfig(), 23177 Keying.config({ 23178 mode: modeName, 23179 onEscape: toolbarSpec.onEscape, 23180 selector: '.tox-toolbar__group' 23181 }), 23182 config('toolbar-events', [onAttached]) 23183 ]); 23184 }; 23185 var renderMoreToolbarCommon = function (toolbarSpec) { 23186 var modeName = toolbarSpec.cyclicKeying ? 'cyclic' : 'acyclic'; 23187 return { 23188 uid: toolbarSpec.uid, 23189 dom: { 23190 tag: 'div', 23191 classes: ['tox-toolbar-overlord'] 23192 }, 23193 parts: { 23194 'overflow-group': renderToolbarGroupCommon({ 23195 title: Optional.none(), 23196 items: [] 23197 }), 23198 'overflow-button': renderIconButtonSpec({ 23199 name: 'more', 23200 icon: Optional.some('more-drawer'), 23201 disabled: false, 23202 tooltip: Optional.some('More...'), 23203 primary: false, 23204 borderless: false 23205 }, Optional.none(), toolbarSpec.providers) 23206 }, 23207 splitToolbarBehaviours: getToolbarbehaviours(toolbarSpec, modeName) 23208 }; 23209 }; 23210 var renderFloatingMoreToolbar = function (toolbarSpec) { 23211 var baseSpec = renderMoreToolbarCommon(toolbarSpec); 23212 var overflowXOffset = 4; 23213 var primary = SplitFloatingToolbar.parts.primary({ 23214 dom: { 23215 tag: 'div', 23216 classes: ['tox-toolbar__primary'] 23217 } 23218 }); 23219 return SplitFloatingToolbar.sketch(__assign(__assign({}, baseSpec), { 23220 lazySink: toolbarSpec.getSink, 23221 getOverflowBounds: function () { 23222 var headerElem = toolbarSpec.moreDrawerData.lazyHeader().element; 23223 var headerBounds = absolute$1(headerElem); 23224 var docElem = documentElement(headerElem); 23225 var docBounds = absolute$1(docElem); 23226 var height = Math.max(docElem.dom.scrollHeight, docBounds.height); 23227 return bounds$1(headerBounds.x + overflowXOffset, docBounds.y, headerBounds.width - overflowXOffset * 2, height); 23228 }, 23229 parts: __assign(__assign({}, baseSpec.parts), { 23230 overflow: { 23231 dom: { 23232 tag: 'div', 23233 classes: ['tox-toolbar__overflow'], 23234 attributes: toolbarSpec.attributes 23235 } 23236 } 23237 }), 23238 components: [primary], 23239 markers: { overflowToggledClass: 'tox-tbtn--enabled' } 23240 })); 23241 }; 23242 var renderSlidingMoreToolbar = function (toolbarSpec) { 23243 var primary = SplitSlidingToolbar.parts.primary({ 23244 dom: { 23245 tag: 'div', 23246 classes: ['tox-toolbar__primary'] 23247 } 23248 }); 23249 var overflow = SplitSlidingToolbar.parts.overflow({ 23250 dom: { 23251 tag: 'div', 23252 classes: ['tox-toolbar__overflow'] 23253 } 23254 }); 23255 var baseSpec = renderMoreToolbarCommon(toolbarSpec); 23256 return SplitSlidingToolbar.sketch(__assign(__assign({}, baseSpec), { 23257 components: [ 23258 primary, 23259 overflow 23260 ], 23261 markers: { 23262 openClass: 'tox-toolbar__overflow--open', 23263 closedClass: 'tox-toolbar__overflow--closed', 23264 growingClass: 'tox-toolbar__overflow--growing', 23265 shrinkingClass: 'tox-toolbar__overflow--shrinking', 23266 overflowToggledClass: 'tox-tbtn--enabled' 23267 }, 23268 onOpened: function (comp) { 23269 comp.getSystem().broadcastOn([toolbarHeightChange()], { type: 'opened' }); 23270 }, 23271 onClosed: function (comp) { 23272 comp.getSystem().broadcastOn([toolbarHeightChange()], { type: 'closed' }); 23273 } 23274 })); 23275 }; 23276 var renderToolbar = function (toolbarSpec) { 23277 var modeName = toolbarSpec.cyclicKeying ? 'cyclic' : 'acyclic'; 23278 return Toolbar.sketch({ 23279 uid: toolbarSpec.uid, 23280 dom: { 23281 tag: 'div', 23282 classes: ['tox-toolbar'].concat(toolbarSpec.type === ToolbarMode.scrolling ? ['tox-toolbar--scrolling'] : []) 23283 }, 23284 components: [Toolbar.parts.groups({})], 23285 toolbarBehaviours: getToolbarbehaviours(toolbarSpec, modeName) 23286 }); 23287 }; 23288 23289 var groupToolbarButtonSchema = objOf([
23290 strictString('type'), 23291 strictOf('items', oneOf([ 23292 arrOfObj$1([ 23293 strictString('name'), 23294 strictArrayOf('items', string) 23295 ]), 23296 string 23297 ])) 23298 ].concat(baseToolbarButtonFields)); 23299 var createGroupToolbarButton = function (spec) { 23300 return asRaw('GroupToolbarButton', groupToolbarButtonSchema, spec); 23301 }; 23302 23303 var baseMenuButtonFields = [ 23304 optionString('text'), 23305 optionString('tooltip'), 23306 optionString('icon'), 23307 strictFunction('fetch'), 23308 defaultedFunction('onSetup', function () { 23309 return noop; 23310 }) 23311 ]; 23312 23313 var MenuButtonSchema = objOf(__spreadArrays([strictString('type')], baseMenuButtonFields)); 23314 var createMenuButton = function (spec) { 23315 return asRaw('menubutton', MenuButtonSchema, spec); 23316 }; 23317 23318 var splitButtonSchema = objOf([ 23319 strictString('type'), 23320 optionString('tooltip'), 23321 optionString('icon'), 23322 optionString('text'), 23323 optionFunction('select'), 23324 strictFunction('fetch'), 23325 defaultedFunction('onSetup', function () { 23326 return noop; 23327 }), 23328 defaultedStringEnum('presets', 'normal', [ 23329 'normal', 23330 'color', 23331 'listpreview' 23332 ]), 23333 defaulted$1('columns', 1), 23334 strictFunction('onAction'), 23335 strictFunction('onItemAction') 23336 ]); 23337 var createSplitButton = function (spec) { 23338 return asRaw('SplitButton', splitButtonSchema, spec); 23339 }; 23340 23341 var events$e = function (reflectingConfig, reflectingState) { 23342 var update = function (component, data) { 23343 reflectingConfig.updateState.each(function (updateState) { 23344 var newState = updateState(component, data); 23345 reflectingState.set(newState); 23346 }); 23347 reflectingConfig.renderComponents.each(function (renderComponents) { 23348 var newComponents = renderComponents(data, reflectingState.get()); 23349 var newChildren = map(newComponents, component.getSystem().build); 23350 replaceChildren(component, newChildren); 23351 }); 23352 }; 23353 return derive([ 23354 run(receive(), function (component, message) { 23355 var receivingData = message; 23356 if (!receivingData.universal) { 23357 var channel = reflectingConfig.channel; 23358 if (contains(receivingData.channels, channel)) { 23359 update(component, receivingData.data); 23360 } 23361 } 23362 }), 23363 runOnAttached(function (comp, _se) { 23364 reflectingConfig.initialData.each(function (rawData) { 23365 update(comp, rawData); 23366 }); 23367 }) 23368 ]); 23369 }; 23370 23371 var ActiveReflecting = /*#__PURE__*/Object.freeze({ 23372 __proto__: null, 23373 events: events$e 23374 }); 23375 23376 var getState$2 = function (component, replaceConfig, reflectState) { 23377 return reflectState; 23378 }; 23379 23380 var ReflectingApis = /*#__PURE__*/Object.freeze({ 23381 __proto__: null, 23382 getState: getState$2 23383 }); 23384 23385 var ReflectingSchema = [ 23386 strict$1('channel'), 23387 option('renderComponents'), 23388 option('updateState'), 23389 option('initialData') 23390 ]; 23391 23392 var init$a = function () { 23393 var cell = Cell(Optional.none()); 23394 var set = function (optS) { 23395 return cell.set(optS); 23396 }; 23397 var clear = function () { 23398 return cell.set(Optional.none()); 23399 }; 23400 var get = function () { 23401 return cell.get(); 23402 }; 23403 var readState = function () { 23404 return cell.get().fold(function () { 23405 return 'none'; 23406 }, function (x) { 23407 return x; 23408 }); 23409 }; 23410 return { 23411 readState: readState, 23412 get: get, 23413 set: set, 23414 clear: clear 23415 }; 23416 }; 23417 23418 var ReflectingState = /*#__PURE__*/Object.freeze({ 23419 __proto__: null, 23420 init: init$a 23421 }); 23422 23423 var Reflecting = create$1({ 23424 fields: ReflectingSchema, 23425 name: 'reflecting', 23426 active: ActiveReflecting, 23427 apis: ReflectingApis, 23428 state: ReflectingState 23429 }); 23430 23431 var schema$q = constant([ 23432 strict$1('toggleClass'), 23433 strict$1('fetch'), 23434 onStrictHandler('onExecute'), 23435 defaulted$1('getHotspot', Optional.some), 23436 defaulted$1('getAnchorOverrides', constant({})), 23437 schema$1(), 23438 onStrictHandler('onItemExecute'), 23439 option('lazySink'),
23440 strict$1('dom'), 23441 onHandler('onOpen'), 23442 field$1('splitDropdownBehaviours', [ 23443 Coupling, 23444 Keying, 23445 Focusing 23446 ]), 23447 defaulted$1('matchWidth', false), 23448 defaulted$1('useMinWidth', false), 23449 defaulted$1('eventOrder', {}), 23450 option('role') 23451 ].concat(sandboxFields())); 23452 var arrowPart = required({ 23453 factory: Button, 23454 schema: [strict$1('dom')], 23455 name: 'arrow', 23456 defaults: function () { 23457 return { buttonBehaviours: derive$1([Focusing.revoke()]) }; 23458 }, 23459 overrides: function (detail) { 23460 return { 23461 dom: { 23462 tag: 'span', 23463 attributes: { role: 'presentation' } 23464 }, 23465 action: function (arrow) { 23466 arrow.getSystem().getByUid(detail.uid).each(emitExecute); 23467 }, 23468 buttonBehaviours: derive$1([Toggling.config({ 23469 toggleOnExecute: false, 23470 toggleClass: detail.toggleClass 23471 })]) 23472 }; 23473 } 23474 }); 23475 var buttonPart = required({ 23476 factory: Button, 23477 schema: [strict$1('dom')], 23478 name: 'button', 23479 defaults: function () { 23480 return { buttonBehaviours: derive$1([Focusing.revoke()]) }; 23481 }, 23482 overrides: function (detail) { 23483 return { 23484 dom: { 23485 tag: 'span', 23486 attributes: { role: 'presentation' } 23487 }, 23488 action: function (btn) { 23489 btn.getSystem().getByUid(detail.uid).each(function (splitDropdown) { 23490 detail.onExecute(splitDropdown, btn); 23491 }); 23492 } 23493 }; 23494 } 23495 }); 23496 var parts$c = constant([ 23497 arrowPart, 23498 buttonPart, 23499 optional({ 23500 factory: { 23501 sketch: function (spec) { 23502 return { 23503 uid: spec.uid, 23504 dom: { 23505 tag: 'span', 23506 styles: { display: 'none' }, 23507 attributes: { 'aria-hidden': 'true' }, 23508 innerHtml: spec.text 23509 } 23510 }; 23511 } 23512 }, 23513 schema: [strict$1('text')], 23514 name: 'aria-descriptor' 23515 }), 23516 external$1({ 23517 schema: [tieredMenuMarkers()], 23518 name: 'menu', 23519 defaults: function (detail) { 23520 return { 23521 onExecute: function (tmenu, item) { 23522 tmenu.getSystem().getByUid(detail.uid).each(function (splitDropdown) { 23523 detail.onItemExecute(splitDropdown, tmenu, item); 23524 }); 23525 } 23526 }; 23527 } 23528 }), 23529 partType() 23530 ]); 23531 23532 var factory$e = function (detail, components, spec, externals) { 23533 var _a; 23534 var switchToMenu = function (sandbox) { 23535 Composing.getCurrent(sandbox).each(function (current) { 23536 Highlighting.highlightFirst(current); 23537 Keying.focusIn(current); 23538 }); 23539 }; 23540 var action = function (component) { 23541 var onOpenSync = switchToMenu; 23542 togglePopup(detail, function (x) { 23543 return x; 23544 }, component, externals, onOpenSync, HighlightOnOpen.HighlightFirst).get(noop); 23545 }; 23546 var openMenu = function (comp) { 23547 action(comp); 23548 return Optional.some(true); 23549 }; 23550 var executeOnButton = function (comp) { 23551 var button = getPartOrDie(comp, detail, 'button'); 23552 emitExecute(button); 23553 return Optional.some(true); 23554 }; 23555 var buttonEvents = __assign(__assign({}, derive([runOnAttached(function (component, _simulatedEvent) { 23556 var ariaDescriptor = getPart(component, detail, 'aria-descriptor'); 23557 ariaDescriptor.each(function (descriptor) { 23558 var descriptorId = generate$1('aria'); 23559 set$1(descriptor.element, 'id', descriptorId); 23560 set$1(component.element, 'aria-describedby', descriptorId); 23561 }); 23562 })])), events$7(Optional.some(action))); 23563 var apis = { 23564 repositionMenus: function (comp) { 23565 if (Toggling.isOn(comp)) { 23566 repositionMenus(comp); 23567 } 23568 } 23569 }; 23570 return { 23571 uid: detail.uid, 23572 dom: detail.dom, 23573 components: components, 23574 apis: apis, 23575 eventOrder: __assign(__assign({}, detail.eventOrder), (_a = {}, _a[execute()] = [ 23576 'disabling', 23577 'toggling', 23578 'alloy.base.behaviour' 23579 ], _a)), 23580 events: buttonEvents, 23581 behaviours: augment(detail.splitDropdownBehaviours, [ 23582 Coupling.config({ 23583 others: { 23584 sandbox: function (hotspot) { 23585 var arrow = getPartOrDie(hotspot, detail, 'arrow'); 23586 var extras = { 23587 onOpen: function () { 23588 Toggling.on(arrow);
23589 Toggling.on(hotspot); 23590 }, 23591 onClose: function () { 23592 Toggling.off(arrow); 23593 Toggling.off(hotspot); 23594 } 23595 }; 23596 return makeSandbox(detail, hotspot, extras); 23597 } 23598 } 23599 }), 23600 Keying.config({ 23601 mode: 'special', 23602 onSpace: executeOnButton, 23603 onEnter: executeOnButton, 23604 onDown: openMenu 23605 }), 23606 Focusing.config({}), 23607 Toggling.config({ 23608 toggleOnExecute: false, 23609 aria: { mode: 'expanded' } 23610 }) 23611 ]), 23612 domModification: { 23613 attributes: { 23614 'role': detail.role.getOr('button'), 23615 'aria-haspopup': true 23616 } 23617 } 23618 }; 23619 }; 23620 var SplitDropdown = composite$1({ 23621 name: 'SplitDropdown', 23622 configFields: schema$q(), 23623 partFields: parts$c(), 23624 factory: factory$e, 23625 apis: { 23626 repositionMenus: function (apis, comp) { 23627 return apis.repositionMenus(comp); 23628 } 23629 } 23630 }); 23631 23632 var getButtonApi = function (component) { 23633 return { 23634 isDisabled: function () { 23635 return Disabling.isDisabled(component); 23636 }, 23637 setDisabled: function (state) { 23638 return Disabling.set(component, state); 23639 } 23640 }; 23641 }; 23642 var getToggleApi = function (component) { 23643 return { 23644 setActive: function (state) { 23645 Toggling.set(component, state); 23646 }, 23647 isActive: function () { 23648 return Toggling.isOn(component); 23649 }, 23650 isDisabled: function () { 23651 return Disabling.isDisabled(component); 23652 }, 23653 setDisabled: function (state) { 23654 return Disabling.set(component, state); 23655 } 23656 }; 23657 }; 23658 var getTooltipAttributes = function (tooltip, providersBackstage) { 23659 return tooltip.map(function (tooltip) { 23660 return { 23661 'aria-label': providersBackstage.translate(tooltip), 23662 'title': providersBackstage.translate(tooltip) 23663 }; 23664 }).getOr({}); 23665 }; 23666 var focusButtonEvent = generate$1('focus-button'); 23667 var rtlIcon$1 = [ 23668 'checklist', 23669 'ordered-list' 23670 ]; 23671 var rtlTransform$1 = [ 23672 'indent', 23673 'outdent', 23674 'table-insert-column-after', 23675 'table-insert-column-before', 23676 'unordered-list' 23677 ]; 23678 var renderCommonStructure = function (icon, text, tooltip, receiver, behaviours, providersBackstage) { 23679 var _d; 23680 var getIconName = function (iconName) { 23681 return global$6.isRtl() && contains(rtlIcon$1, iconName) ? iconName + '-rtl' : iconName; 23682 }; 23683 var needsRtlClass = global$6.isRtl() && icon.exists(function (name) { 23684 return contains(rtlTransform$1, name); 23685 }); 23686 return { 23687 dom: { 23688 tag: 'button', 23689 classes: ['tox-tbtn'].concat(text.isSome() ? ['tox-tbtn--select'] : []).concat(needsRtlClass ? ['tox-tbtn__icon-rtl'] : []), 23690 attributes: getTooltipAttributes(tooltip, providersBackstage) 23691 }, 23692 components: componentRenderPipeline([ 23693 icon.map(function (iconName) { 23694 return renderIconFromPack(getIconName(iconName), providersBackstage.icons); 23695 }), 23696 text.map(function (text) { 23697 return renderLabel$1(text, 'tox-tbtn', providersBackstage); 23698 }) 23699 ]), 23700 eventOrder: (_d = {}, _d[mousedown()] = [ 23701 'focusing', 23702 'alloy.base.behaviour', 23703 'common-button-display-events' 23704 ], _d), 23705 buttonBehaviours: derive$1([ 23706 DisablingConfigs.toolbarButton(providersBackstage.isDisabled), 23707 receivingConfig(), 23708 config('common-button-display-events', [run(mousedown(), function (button, se) { 23709 se.event.prevent(); 23710 emit(button, focusButtonEvent); 23711 })]) 23712 ].concat(receiver.map(function (r) { 23713 return Reflecting.config({ 23714 channel: r, 23715 initialData: { 23716 icon: icon, 23717 text: text 23718 }, 23719 renderComponents: function (data, _state) { 23720 return componentRenderPipeline([ 23721 data.icon.map(function (iconName) { 23722 return renderIconFromPack(getIconName(iconName), providersBackstage.icons); 23723 }), 23724 data.text.map(function (text) { 23725 return renderLabel$1(text, 'tox-tbtn', providersBackstage); 23726 }) 23727 ]); 23728 } 23729 }); 23730 }
23730).toArray()).concat(behaviours.getOr([]))) 23731 }; 23732 }; 23733 var renderFloatingToolbarButton = function (spec, backstage, identifyButtons, attributes) { 23734 var sharedBackstage = backstage.shared; 23735 return FloatingToolbarButton.sketch({ 23736 lazySink: sharedBackstage.getSink, 23737 fetch: function () { 23738 return Future.nu(function (resolve) { 23739 resolve(map(identifyButtons(spec.items), renderToolbarGroup)); 23740 }); 23741 }, 23742 markers: { toggledClass: 'tox-tbtn--enabled' }, 23743 parts: { 23744 button: renderCommonStructure(spec.icon, spec.text, spec.tooltip, Optional.none(), Optional.none(), sharedBackstage.providers), 23745 toolbar: { 23746 dom: { 23747 tag: 'div', 23748 classes: ['tox-toolbar__overflow'], 23749 attributes: attributes 23750 } 23751 } 23752 } 23753 }); 23754 }; 23755 var renderCommonToolbarButton = function (spec, specialisation, providersBackstage) { 23756 var editorOffCell = Cell(noop); 23757 var structure = renderCommonStructure(spec.icon, spec.text, spec.tooltip, Optional.none(), Optional.none(), providersBackstage); 23758 return Button.sketch({ 23759 dom: structure.dom, 23760 components: structure.components, 23761 eventOrder: toolbarButtonEventOrder, 23762 buttonBehaviours: derive$1([ 23763 config('toolbar-button-events', [ 23764 onToolbarButtonExecute({ 23765 onAction: spec.onAction, 23766 getApi: specialisation.getApi 23767 }), 23768 onControlAttached(specialisation, editorOffCell), 23769 onControlDetached(specialisation, editorOffCell) 23770 ]), 23771 DisablingConfigs.toolbarButton(function () { 23772 return spec.disabled || providersBackstage.isDisabled(); 23773 }), 23774 receivingConfig() 23775 ].concat(specialisation.toolbarButtonBehaviours)) 23776 }); 23777 }; 23778 var renderToolbarButton = function (spec, providersBackstage) { 23779 return renderToolbarButtonWith(spec, providersBackstage, []); 23780 }; 23781 var renderToolbarButtonWith = function (spec, providersBackstage, bonusEvents) { 23782 return renderCommonToolbarButton(spec, { 23783 toolbarButtonBehaviours: [].concat(bonusEvents.length > 0 ? [config('toolbarButtonWith', bonusEvents)] : []), 23784 getApi: getButtonApi, 23785 onSetup: spec.onSetup 23786 }, providersBackstage); 23787 }; 23788 var renderToolbarToggleButton = function (spec, providersBackstage) { 23789 return renderToolbarToggleButtonWith(spec, providersBackstage, []); 23790 }; 23791 var renderToolbarToggleButtonWith = function (spec, providersBackstage, bonusEvents) { 23792 return deepMerge(renderCommonToolbarButton(spec, { 23793 toolbarButtonBehaviours: [ 23794 Replacing.config({}), 23795 Toggling.config({ 23796 toggleClass: 'tox-tbtn--enabled', 23797 aria: { mode: 'pressed' }, 23798 toggleOnExecute: false 23799 }) 23800 ].concat(bonusEvents.length > 0 ? [config('toolbarToggleButtonWith', bonusEvents)] : []), 23801 getApi: getToggleApi, 23802 onSetup: spec.onSetup 23803 }, providersBackstage)); 23804 }; 23805 var fetchChoices = function (getApi, spec, providersBackstage) { 23806 return function (comp) { 23807 return Future.nu(function (callback) { 23808 return spec.fetch(callback); 23809 }).map(function (items) { 23810 return Optional.from(createTieredDataFrom(deepMerge(createPartialChoiceMenu(generate$1('menu-value'), items, function (value) { 23811 spec.onItemAction(getApi(comp), value); 23812 }, spec.columns, spec.presets, ItemResponse$1.CLOSE_ON_EXECUTE, spec.select.getOr(never), providersBackstage), { 23813 movement: deriveMenuMovement(spec.columns, spec.presets), 23814 menuBehaviours: SimpleBehaviours.unnamedEvents(spec.columns !== 'auto' ? [] : [runOnAttached(function (comp, _se) { 23815 detectSize(comp, 4, classForPreset(spec.presets)).each(function (_d) { 23816 var numRows = _d.numRows, numColumns = _d.numColumns; 23817 Keying.setGridSize(comp, numRows, numColumns); 23818 }); 23819 })]) 23820 }))); 23821 }); 23822 }; 23823 }; 23824 var renderSplitButton = function (spec, sharedBackstage) { 23825 var _d; 23826 var displayChannel = generate$1('channel-update-split-dropdown-display'); 23827 var getApi = function (comp) { 23828 return { 23829 isDisabled: function () { 23830 return Disabling.isDisabled(comp); 23831 }, 23832 setDisabled: function (state) { 23833 return Disabling.set(comp, state); 23834 }, 23835 setIconFill: function (id, value) { 23836 descendant$1(comp.element, 'svg path[id="' + id + '"], rect[id="' + id + '"]').each(function (underlinePath) { 23837 set$1(underlinePath, 'fill', value); 23838 }); 23839 }, 23840 setIconStroke: function (id, value) { 23841 descendant$1(comp.element, 'svg path[id="' + id + '"], rect[id="' + id + '"]').each(function (underlinePath) { 23842 set$1(underlinePath, 'stroke', value); 23843 }); 23844 },
23845 setActive: function (state) { 23846 if (comp.getSystem().isConnected()) { 23847 set$1(comp.element, 'aria-pressed', state); 23848 descendant$1(comp.element, 'span').each(function (button) { 23849 comp.getSystem().getByDom(button).each(function (buttonComp) { 23850 return Toggling.set(buttonComp, state); 23851 }); 23852 }); 23853 } 23854 }, 23855 isActive: function () { 23856 return descendant$1(comp.element, 'span').exists(function (button) { 23857 if (comp.getSystem().isConnected()) { 23858 return comp.getSystem().getByDom(button).exists(Toggling.isOn); 23859 } else { 23860 return false; 23861 } 23862 }); 23863 } 23864 }; 23865 }; 23866 var editorOffCell = Cell(noop); 23867 var specialisation = { 23868 getApi: getApi, 23869 onSetup: spec.onSetup 23870 }; 23871 return SplitDropdown.sketch({ 23872 dom: { 23873 tag: 'div', 23874 classes: ['tox-split-button'], 23875 attributes: __assign({ 'aria-pressed': false }, getTooltipAttributes(spec.tooltip, sharedBackstage.providers)) 23876 }, 23877 onExecute: function (button) { 23878 spec.onAction(getApi(button)); 23879 }, 23880 onItemExecute: function (_a, _b, _c) { 23881 }, 23882 splitDropdownBehaviours: derive$1([ 23883 DisablingConfigs.splitButton(sharedBackstage.providers.isDisabled), 23884 receivingConfig(), 23885 config('split-dropdown-events', [ 23886 run(focusButtonEvent, Focusing.focus), 23887 onControlAttached(specialisation, editorOffCell), 23888 onControlDetached(specialisation, editorOffCell) 23889 ]), 23890 Unselecting.config({}) 23891 ]), 23892 eventOrder: (_d = {}, _d[attachedToDom()] = [ 23893 'alloy.base.behaviour', 23894 'split-dropdown-events' 23895 ], _d), 23896 toggleClass: 'tox-tbtn--enabled', 23897 lazySink: sharedBackstage.getSink, 23898 fetch: fetchChoices(getApi, spec, sharedBackstage.providers), 23899 parts: { menu: part(false, spec.columns, spec.presets) }, 23900 components: [ 23901 SplitDropdown.parts.button(renderCommonStructure(spec.icon, spec.text, Optional.none(), Optional.some(displayChannel), Optional.some([Toggling.config({ 23902 toggleClass: 'tox-tbtn--enabled', 23903 toggleOnExecute: false 23904 })]), sharedBackstage.providers)), 23905 SplitDropdown.parts.arrow({ 23906 dom: { 23907 tag: 'button', 23908 classes: [ 23909 'tox-tbtn', 23910 'tox-split-button__chevron' 23911 ], 23912 innerHtml: get$e('chevron-down', sharedBackstage.providers.icons) 23913 }, 23914 buttonBehaviours: derive$1([ 23915 DisablingConfigs.splitButton(sharedBackstage.providers.isDisabled), 23916 receivingConfig() 23917 ]) 23918 }), 23919 SplitDropdown.parts['aria-descriptor']({ text: sharedBackstage.providers.translate('To open the popup, press Shift+Enter') }) 23920 ] 23921 }); 23922 }; 23923 23924 var getFormApi = function (input) { 23925 return { 23926 hide: function () { 23927 return emit(input, sandboxClose()); 23928 }, 23929 getValue: function () { 23930 return Representing.getValue(input); 23931 } 23932 }; 23933 }; 23934 var runOnExecute$1 = function (memInput, original) { 23935 return run(internalToolbarButtonExecute, function (comp, se) { 23936 var input = memInput.get(comp); 23937 var formApi = getFormApi(input); 23938 original.onAction(formApi, se.event.buttonApi); 23939 }); 23940 }; 23941 var renderContextButton = function (memInput, button, extras) { 23942 var _a = button.original, primary = _a.primary, rest = __rest(_a, ['primary']); 23943 var bridged = getOrDie(createToolbarButton(__assign(__assign({}, rest), { 23944 type: 'button', 23945 onAction: noop 23946 }))); 23947 return renderToolbarButtonWith(bridged, extras.backstage.shared.providers, [runOnExecute$1(memInput, button)]); 23948 }; 23949 var renderContextToggleButton = function (memInput, button, extras) { 23950 var _a = button.original, primary = _a.primary, rest = __rest(_a, ['primary']); 23951 var bridged = getOrDie(createToggleButton(__assign(__assign({}, rest), { 23952 type: 'togglebutton', 23953 onAction: noop 23954 })));
23955 return renderToolbarToggleButtonWith(bridged, extras.backstage.shared.providers, [runOnExecute$1(memInput, button)]); 23956 }; 23957 var generateOne$1 = function (memInput, button, providersBackstage) { 23958 var extras = { backstage: { shared: { providers: providersBackstage } } }; 23959 if (button.type === 'contextformtogglebutton') { 23960 return renderContextToggleButton(memInput, button, extras); 23961 } else { 23962 return renderContextButton(memInput, button, extras); 23963 } 23964 }; 23965 var generate$7 = function (memInput, buttons, providersBackstage) { 23966 var mementos = map(buttons, function (button) { 23967 return record(generateOne$1(memInput, button, providersBackstage)); 23968 }); 23969 var asSpecs = function () { 23970 return map(mementos, function (mem) { 23971 return mem.asSpec(); 23972 }); 23973 }; 23974 var findPrimary = function (compInSystem) { 23975 return findMap(buttons, function (button, i) { 23976 if (button.primary) { 23977 return Optional.from(mementos[i]).bind(function (mem) { 23978 return mem.getOpt(compInSystem); 23979 }).filter(not(Disabling.isDisabled)); 23980 } else { 23981 return Optional.none(); 23982 } 23983 }); 23984 }; 23985 return { 23986 asSpecs: asSpecs, 23987 findPrimary: findPrimary 23988 }; 23989 }; 23990 23991 var buildInitGroups = function (ctx, providers) { 23992 var inputAttributes = ctx.label.fold(function () { 23993 return {}; 23994 }, function (label) { 23995 return { 'aria-label': label }; 23996 }); 23997 var memInput = record(Input.sketch({ 23998 inputClasses: [ 23999 'tox-toolbar-textfield', 24000 'tox-toolbar-nav-js' 24001 ], 24002 data: ctx.initValue(), 24003 inputAttributes: inputAttributes, 24004 selectOnFocus: true, 24005 inputBehaviours: derive$1([Keying.config({ 24006 mode: 'special', 24007 onEnter: function (input) { 24008 return commands.findPrimary(input).map(function (primary) { 24009 emitExecute(primary); 24010 return true; 24011 }); 24012 }, 24013 onLeft: function (comp, se) { 24014 se.cut(); 24015 return Optional.none(); 24016 }, 24017 onRight: function (comp, se) { 24018 se.cut(); 24019 return Optional.none(); 24020 } 24021 })]) 24022 })); 24023 var commands = generate$7(memInput, ctx.commands, providers); 24024 return [ 24025 { 24026 title: Optional.none(), 24027 items: [memInput.asSpec()] 24028 }, 24029 { 24030 title: Optional.none(), 24031 items: commands.asSpecs() 24032 } 24033 ]; 24034 }; 24035 var renderContextForm = function (toolbarType, ctx, providers) { 24036 return renderToolbar({ 24037 type: toolbarType, 24038 uid: generate$1('context-toolbar'), 24039 initGroups: buildInitGroups(ctx, providers), 24040 onEscape: Optional.none, 24041 cyclicKeying: true, 24042 providers: providers 24043 }); 24044 }; 24045 var ContextForm = { 24046 renderContextForm: renderContextForm, 24047 buildInitGroups: buildInitGroups 24048 }; 24049 24050 var getHorizontalBounds = function (contentAreaBox, viewportBounds) { 24051 var x = Math.max(viewportBounds.x, contentAreaBox.x); 24052 var contentBoxWidth = contentAreaBox.right - x; 24053 var maxViewportWidth = viewportBounds.width - (x - viewportBounds.x); 24054 var width = Math.min(contentBoxWidth, maxViewportWidth); 24055 return { 24056 x: x, 24057 width: width 24058 }; 24059 }; 24060 var getVerticalBounds = function (editor, contentAreaBox, viewportBounds, isToolbarLocationTop) { 24061 var container = SugarElement.fromDom(editor.getContainer()); 24062 var header = descendant$1(container, '.tox-editor-header').getOr(container); 24063 var headerBox = box(header); 24064 var isToolbarBelowContentArea = headerBox.y >= contentAreaBox.bottom; 24065 var isToolbarAbove = isToolbarLocationTop && !isToolbarBelowContentArea; 24066 if (editor.inline && isToolbarAbove) { 24067 return { 24068 y: Math.max(headerBox.bottom, viewportBounds.y), 24069 bottom: viewportBounds.bottom 24070 }; 24071 } 24072 if (editor.inline && !isToolbarAbove) { 24073 return { 24074 y: viewportBounds.y, 24075 bottom: Math.min(headerBox.y, viewportBounds.bottom) 24076 }; 24077 } 24078 var containerBounds = box(container); 24079 if (isToolbarAbove) { 24080 return { 24081 y: Math.max(headerBox.bottom, viewportBounds.y), 24082 bottom: Math.min(containerBounds.bottom, viewportBounds.bottom) 24083 }; 24084 } 24085 return { 24086 y: Math.max(containerBounds.y, viewportBounds.y), 24087 bottom: Math.min(headerBox.y, viewportBounds.bottom) 24088 }; 24089 }; 24090 var getContextToolbarBounds = function (editor, sharedBackstage) { 24091 var viewportBounds = getBounds(window); 24092 var contentAreaBox = box(SugarElement.fromDom(editor.getContentAreaContainer()));
24093 var toolbarOrMenubarEnabled = isMenubarEnabled(editor) || isToolbarEnabled(editor) || isMultipleToolbars(editor); 24094 var _a = getHorizontalBounds(contentAreaBox, viewportBounds), x = _a.x, width = _a.width; 24095 if (editor.inline && !toolbarOrMenubarEnabled) { 24096 return bounds$1(x, viewportBounds.y, width, viewportBounds.height); 24097 } else { 24098 var isToolbarTop = sharedBackstage.header.isPositionedAtTop(); 24099 var _b = getVerticalBounds(editor, contentAreaBox, viewportBounds, isToolbarTop), y = _b.y, bottom = _b.bottom; 24100 return bounds$1(x, y, width, bottom - y); 24101 } 24102 }; 24103 24104 var matchTargetWith = function (elem, candidates) { 24105 var ctxs = filter(candidates, function (toolbarApi) { 24106 return toolbarApi.predicate(elem.dom); 24107 }); 24108 var _a = partition(ctxs, function (t) { 24109 return t.type === 'contexttoolbar'; 24110 }), pass = _a.pass, fail = _a.fail; 24111 return { 24112 contextToolbars: pass, 24113 contextForms: fail 24114 }; 24115 }; 24116 var filterByPositionForStartNode = function (toolbars) { 24117 if (toolbars.length <= 1) { 24118 return toolbars; 24119 } else { 24120 var doesPositionExist = function (value) { 24121 return exists(toolbars, function (t) { 24122 return t.position === value; 24123 }); 24124 }; 24125 var filterToolbarsByPosition = function (value) { 24126 return filter(toolbars, function (t) { 24127 return t.position === value; 24128 }); 24129 }; 24130 var hasSelectionToolbars = doesPositionExist('selection'); 24131 var hasNodeToolbars = doesPositionExist('node'); 24132 if (hasSelectionToolbars || hasNodeToolbars) { 24133 if (hasNodeToolbars && hasSelectionToolbars) { 24134 var nodeToolbars = filterToolbarsByPosition('node'); 24135 var selectionToolbars = map(filterToolbarsByPosition('selection'), function (t) { 24136 return __assign(__assign({}, t), { position: 'node' }); 24137 }); 24138 return nodeToolbars.concat(selectionToolbars); 24139 } else { 24140 return hasSelectionToolbars ? filterToolbarsByPosition('selection') : filterToolbarsByPosition('node'); 24141 } 24142 } else { 24143 return filterToolbarsByPosition('line'); 24144 } 24145 } 24146 }; 24147 var filterByPositionForAncestorNode = function (toolbars) { 24148 if (toolbars.length <= 1) { 24149 return toolbars; 24150 } else { 24151 var findPosition_1 = function (value) { 24152 return find(toolbars, function (t) { 24153 return t.position === value; 24154 }); 24155 }; 24156 var basePosition = findPosition_1('selection').orThunk(function () { 24157 return findPosition_1('node'); 24158 }).orThunk(function () { 24159 return findPosition_1('line'); 24160 }).map(function (t) { 24161 return t.position; 24162 }); 24163 return basePosition.fold(function () { 24164 return []; 24165 }, function (pos) { 24166 return filter(toolbars, function (t) { 24167 return t.position === pos; 24168 }); 24169 }); 24170 } 24171 }; 24172 var matchStartNode = function (elem, nodeCandidates, editorCandidates) { 24173 var nodeMatches = matchTargetWith(elem, nodeCandidates); 24174 if (nodeMatches.contextForms.length > 0) { 24175 return Optional.some({ 24176 elem: elem, 24177 toolbars: [nodeMatches.contextForms[0]] 24178 }); 24179 } else { 24180 var editorMatches = matchTargetWith(elem, editorCandidates); 24181 if (editorMatches.contextForms.length > 0) { 24182 return Optional.some({ 24183 elem: elem, 24184 toolbars: [editorMatches.contextForms[0]] 24185 }); 24186 } else if (nodeMatches.contextToolbars.length > 0 || editorMatches.contextToolbars.length > 0) { 24187 var toolbars = filterByPositionForStartNode(nodeMatches.contextToolbars.concat(editorMatches.contextToolbars)); 24188 return Optional.some({ 24189 elem: elem, 24190 toolbars: toolbars 24191 }); 24192 } else { 24193 return Optional.none(); 24194 } 24195 } 24196 }; 24197 var matchAncestor = function (isRoot, startNode, scopes) { 24198 if (isRoot(startNode)) { 24199 return Optional.none(); 24200 } else { 24201 return ancestor(startNode, function (ancestorElem) { 24202 var _a = matchTargetWith(ancestorElem, scopes.inNodeScope), contextToolbars = _a.contextToolbars, contextForms = _a.contextForms; 24203 var toolbars = contextForms.length > 0 ? contextForms : filterByPositionForAncestorNode(contextToolbars); 24204 return toolbars.length > 0 ? Optional.some({ 24205 elem: ancestorElem, 24206 toolbars: toolbars 24207 }) : Optional.none(); 24208 }, isRoot); 24209 } 24210 }; 24211 var lookup$1 = function (scopes, editor) { 24212 var rootElem = SugarElement.fromDom(editor.getBody());
24213 var isRoot = function (elem) { 24214 return eq$1(elem, rootElem); 24215 }; 24216 var isOutsideRoot = function (startNode) { 24217 return !isRoot(startNode) && !contains$2(rootElem, startNode); 24218 }; 24219 var startNode = SugarElement.fromDom(editor.selection.getNode()); 24220 if (isOutsideRoot(startNode)) { 24221 return Optional.none(); 24222 } 24223 return matchStartNode(startNode, scopes.inNodeScope, scopes.inEditorScope).orThunk(function () { 24224 return matchAncestor(isRoot, startNode, scopes); 24225 }); 24226 }; 24227 24228 var categorise = function (contextToolbars, navigate) { 24229 var forms = {}; 24230 var inNodeScope = []; 24231 var inEditorScope = []; 24232 var formNavigators = {}; 24233 var lookupTable = {}; 24234 var registerForm = function (key, toolbarSpec) { 24235 var contextForm = getOrDie(createContextForm(toolbarSpec)); 24236 forms[key] = contextForm; 24237 contextForm.launch.map(function (launch) { 24238 formNavigators['form:' + key + ''] = __assign(__assign({}, toolbarSpec.launch), { 24239 type: launch.type === 'contextformtogglebutton' ? 'togglebutton' : 'button', 24240 onAction: function () { 24241 navigate(contextForm); 24242 } 24243 }); 24244 }); 24245 if (contextForm.scope === 'editor') { 24246 inEditorScope.push(contextForm); 24247 } else { 24248 inNodeScope.push(contextForm); 24249 } 24250 lookupTable[key] = contextForm; 24251 }; 24252 var registerToolbar = function (key, toolbarSpec) { 24253 createContextToolbar(toolbarSpec).each(function (contextToolbar) { 24254 if (toolbarSpec.scope === 'editor') { 24255 inEditorScope.push(contextToolbar); 24256 } else { 24257 inNodeScope.push(contextToolbar); 24258 } 24259 lookupTable[key] = contextToolbar; 24260 }); 24261 }; 24262 var keys$1 = keys(contextToolbars); 24263 each(keys$1, function (key) { 24264 var toolbarApi = contextToolbars[key]; 24265 if (toolbarApi.type === 'contextform') { 24266 registerForm(key, toolbarApi); 24267 } else if (toolbarApi.type === 'contexttoolbar') { 24268 registerToolbar(key, toolbarApi); 24269 } 24270 }); 24271 return { 24272 forms: forms, 24273 inNodeScope: inNodeScope, 24274 inEditorScope: inEditorScope, 24275 lookupTable: lookupTable, 24276 formNavigators: formNavigators 24277 }; 24278 }; 24279 24280 var forwardSlideEvent = generate$1('forward-slide'); 24281 var backSlideEvent = generate$1('backward-slide'); 24282 var changeSlideEvent = generate$1('change-slide-event'); 24283 var resizingClass = 'tox-pop--resizing'; 24284 var renderContextToolbar = function (spec) { 24285 var stack = Cell([]); 24286 return InlineView.sketch({ 24287 dom: { 24288 tag: 'div', 24289 classes: ['tox-pop'] 24290 }, 24291 fireDismissalEventInstead: { event: 'doNotDismissYet' }, 24292 onShow: function (comp) { 24293 stack.set([]); 24294 InlineView.getContent(comp).each(function (c) { 24295 remove$6(c.element, 'visibility'); 24296 }); 24297 remove$4(comp.element, resizingClass); 24298 remove$6(comp.element, 'width'); 24299 }, 24300 inlineBehaviours: derive$1([ 24301 config('context-toolbar-events', [ 24302 runOnSource(transitionend(), function (comp, _se) { 24303 remove$4(comp.element, resizingClass); 24304 remove$6(comp.element, 'width'); 24305 }), 24306 run(changeSlideEvent, function (comp, se) { 24307 var elem = comp.element; 24308 remove$6(elem, 'width'); 24309 var currentWidth = get$8(elem); 24310 InlineView.setContent(comp, se.event.contents); 24311 add$2(elem, resizingClass); 24312 var newWidth = get$8(elem); 24313 set$2(elem, 'width', currentWidth + 'px'); 24314 InlineView.getContent(comp).each(function (newContents) { 24315 se.event.focus.bind(function (f) { 24316 focus$1(f); 24317 return search(elem); 24318 }).orThunk(function () { 24319 Keying.focusIn(newContents); 24320 return active(getRootNode(elem)); 24321 }); 24322 }); 24323 global$2.setTimeout(function () { 24324 set$2(comp.element, 'width', newWidth + 'px'); 24325 }, 0); 24326 }), 24327 run(forwardSlideEvent, function (comp, se) { 24328 InlineView.getContent(comp).each(function (oldContents) { 24329 stack.set(stack.get().concat([{ 24330 bar: oldContents, 24331 focus: active(getRootNode(comp.element)) 24332 }])); 24333 }); 24334 emitWith(comp, changeSlideEvent, { 24335 contents: se.event.forwardContents, 24336 focus: Optional.none() 24337 }); 24338 }), 24339 run(backSlideEvent, function (comp, _se) { 24340 last(stack.get()).each(function (last) { 24341 stack.set(stack.get().slice(0, stack.get().length - 1)); 24342 emitWith(comp, changeSlideEvent, { 24343 contents: premade$1(last.bar), 24344 focus: last.focus 24345 }); 24346 }); 24347 }) 24348 ]), 24349 Keying.config({
24350 mode: 'special', 24351 onEscape: function (comp) { 24352 return last(stack.get()).fold(function () { 24353 return spec.onEscape(); 24354 }, function (_) { 24355 emit(comp, backSlideEvent); 24356 return Optional.some(true); 24357 }); 24358 } 24359 }) 24360 ]), 24361 lazySink: function () { 24362 return Result.value(spec.sink); 24363 } 24364 }); 24365 }; 24366 24367 var generateSelectItems = function (_editor, backstage, spec) { 24368 var generateItem = function (rawItem, response, disabled, value) { 24369 var translatedText = backstage.shared.providers.translate(rawItem.title); 24370 if (rawItem.type === 'separator') { 24371 return Optional.some({ 24372 type: 'separator', 24373 text: translatedText 24374 }); 24375 } else if (rawItem.type === 'submenu') { 24376 var items = bind(rawItem.getStyleItems(), function (si) { 24377 return validate(si, response, value); 24378 }); 24379 if (response === 0 && items.length <= 0) { 24380 return Optional.none(); 24381 } else { 24382 return Optional.some({ 24383 type: 'nestedmenuitem', 24384 text: translatedText, 24385 disabled: items.length <= 0, 24386 getSubmenuItems: function () { 24387 return bind(rawItem.getStyleItems(), function (si) { 24388 return validate(si, response, value); 24389 }); 24390 } 24391 }); 24392 } 24393 } else { 24394 return Optional.some(__assign({ 24395 type: 'togglemenuitem', 24396 text: translatedText, 24397 icon: rawItem.icon, 24398 active: rawItem.isSelected(value), 24399 disabled: disabled, 24400 onAction: spec.onAction(rawItem) 24401 }, rawItem.getStylePreview().fold(function () { 24402 return {}; 24403 }, function (preview) { 24404 return { meta: { style: preview } }; 24405 }))); 24406 } 24407 }; 24408 var validate = function (item, response, value) { 24409 var invalid = item.type === 'formatter' && spec.isInvalid(item); 24410 if (response === 0) { 24411 return invalid ? [] : generateItem(item, response, false, value).toArray(); 24412 } else { 24413 return generateItem(item, response, invalid, value).toArray(); 24414 } 24415 }; 24416 var validateItems = function (preItems) { 24417 var value = spec.getCurrentValue(); 24418 var response = spec.shouldHide ? 0 : 1; 24419 return bind(preItems, function (item) { 24420 return validate(item, response, value); 24421 }); 24422 }; 24423 var getFetch = function (backstage, getStyleItems) { 24424 return function (comp, callback) { 24425 var preItems = getStyleItems(); 24426 var items = validateItems(preItems); 24427 var menu = build$2(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false); 24428 callback(menu); 24429 }; 24430 }; 24431 return { 24432 validateItems: validateItems, 24433 getFetch: getFetch 24434 }; 24435 }; 24436 var createMenuItems = function (editor, backstage, spec) { 24437 var dataset = spec.dataset; 24438 var getStyleItems = dataset.type === 'basic' ? function () { 24439 return map(dataset.data, function (d) { 24440 return processBasic(d, spec.isSelectedFor, spec.getPreviewFor); 24441 }); 24442 } : dataset.getData; 24443 return { 24444 items: generateSelectItems(editor, backstage, spec), 24445 getStyleItems: getStyleItems 24446 }; 24447 }; 24448 var createSelectButton = function (editor, backstage, spec) { 24449 var _a = createMenuItems(editor, backstage, spec), items = _a.items, getStyleItems = _a.getStyleItems; 24450 var getApi = function (comp) { 24451 return { getComponent: constant(comp) }; 24452 }; 24453 var onSetup = function (api) { 24454 var updateText = function () { 24455 var comp = api.getComponent(); 24456 if (comp.getSystem().isConnected()) { 24457 spec.updateText(comp); 24458 } 24459 }; 24460 updateText(); 24461 editor.on('NodeChange', updateText); 24462 return function () { 24463 editor.off('NodeChange', updateText); 24464 }; 24465 }; 24466 return renderCommonDropdown({ 24467 text: spec.icon.isSome() ? Optional.none() : Optional.some(''), 24468 icon: spec.icon, 24469 tooltip: Optional.from(spec.tooltip), 24470 role: Optional.none(), 24471 fetch: items.getFetch(backstage, getStyleItems), 24472 onSetup: onSetup, 24473 getApi: getApi, 24474 columns: 1, 24475 presets: 'normal', 24476 classes: spec.icon.isSome() ? [] : ['bespoke'], 24477 dropdownBehaviours: [] 24478 }, 'tox-tbtn', backstage.shared); 24479 }; 24480 24481 var process = function (rawFormats) { 24482 return map(rawFormats, function (item) { 24483 var title = item, format = item; 24484 var values = item.split('='); 24485 if (values.length > 1) { 24486 title = values[0]; 24487 format = values[1]; 24488 } 24489 return { 24490 title: title, 24491 format: format 24492 }; 24493 }); 24494 }; 24495 var buildBasicStaticDataset = function (data) { 24496 return { 24497 type: 'basic', 24498 data: data 24499 }; 24500 }; 24501 var Delimiter; 24502 (function (Delimiter) { 24503 Delimiter[Delimiter['SemiColon'] = 0] = 'SemiColon'; 24504 Delimiter[Delimiter['Space'] = 1] = 'Space'; 24505 }(Delimiter || (Delimiter = {}))); 24506 var split = function (rawFormats, delimiter) { 24507 if (delimiter === Delimiter.SemiColon) { 24508 return rawFormats.replace(/;$/, '').split(';'); 24509 } else { 24510 return rawFormats.split(' '); 24511 } 24512 }; 24513 var buildBasicSettingsDataset = function (editor, settingName, defaults, delimiter) { 24514 var rawFormats = editor.getParam(settingName, defaults, 'string'); 24515 var data = process(split(rawFormats, delimiter)); 24516 return { 24517 type: 'basic', 24518 data: data 24519 }; 24520 }; 24521 24522 var alignMenuItems = [ 24523 { 24524 title: 'Left', 24525 icon: 'align-left', 24526 format: 'alignleft', 24527 command: 'JustifyLeft' 24528 }, 24529 { 24530 title: 'Center', 24531 icon: 'align-center', 24532 format: 'aligncenter', 24533 command: 'JustifyCenter' 24534 }, 24535 { 24536 title: 'Right', 24537 icon: 'align-right', 24538 format: 'alignright', 24539 command: 'JustifyRight' 24540 }, 24541 { 24542 title: 'Justify', 24543 icon: 'align-justify', 24544 format: 'alignjustify', 24545 command: 'JustifyFull' 24546 } 24547 ]; 24548 var getSpec = function (editor) { 24549 var getMatchingValue = function () { 24550 return find(alignMenuItems, function (item) { 24551 return editor.formatter.match(item.format); 24552 }); 24553 }; 24554 var isSelectedFor = function (format) { 24555 return function () { 24556 return editor.formatter.match(format); 24557 }; 24558 }; 24559 var getPreviewFor = function (_format) { 24560 return function () { 24561 return Optional.none(); 24562 }; 24563 }; 24564 var updateSelectMenuIcon = function (comp) { 24565 var match = getMatchingValue(); 24566 var alignment = match.fold(function () { 24567 return 'left'; 24568 }, function (item) { 24569 return item.title.toLowerCase(); 24570 }); 24571 emitWith(comp, updateMenuIcon, { icon: 'align-' + alignment }); 24572 }; 24573 var dataset = buildBasicStaticDataset(alignMenuItems); 24574 var onAction = function (rawItem) { 24575 return function () { 24576 return find(alignMenuItems, function (item) { 24577 return item.format === rawItem.format; 24578 }).each(function (item) { 24579 return editor.execCommand(item.command); 24580 }); 24581 }; 24582 }; 24583 return { 24584 tooltip: 'Align', 24585 icon: Optional.some('align-left'), 24586 isSelectedFor: isSelectedFor, 24587 getCurrentValue: Optional.none, 24588 getPreviewFor: getPreviewFor, 24589 onAction: onAction, 24590 updateText: updateSelectMenuIcon, 24591 dataset: dataset, 24592 shouldHide: false, 24593 isInvalid: function (item) { 24594 return !editor.formatter.canApply(item.format); 24595 } 24596 }; 24597 }; 24598 var createAlignSelect = function (editor, backstage) { 24599 return createSelectButton(editor, backstage, getSpec(editor)); 24600 }; 24601 var alignSelectMenu = function (editor, backstage) { 24602 var menuItems = createMenuItems(editor, backstage, getSpec(editor)); 24603 editor.ui.registry.addNestedMenuItem('align', { 24604 text: backstage.shared.providers.translate('Align'), 24605 getSubmenuItems: function () {
24606 return menuItems.items.validateItems(menuItems.getStyleItems()); 24607 } 24608 }); 24609 }; 24610 24611 var defaultFontsFormats = 'Andale Mono=andale mono,monospace;' + 'Arial=arial,helvetica,sans-serif;' + 'Arial Black=arial black,sans-serif;' + 'Book Antiqua=book antiqua,palatino,serif;' + 'Comic Sans MS=comic sans ms,sans-serif;' + 'Courier New=courier new,courier,monospace;' + 'Georgia=georgia,palatino,serif;' + 'Helvetica=helvetica,arial,sans-serif;' + 'Impact=impact,sans-serif;' + 'Symbol=symbol;' + 'Tahoma=tahoma,arial,helvetica,sans-serif;' + 'Terminal=terminal,monaco,monospace;' + 'Times New Roman=times new roman,times,serif;' + 'Trebuchet MS=trebuchet ms,geneva,sans-serif;' + 'Verdana=verdana,geneva,sans-serif;' + 'Webdings=webdings;' + 'Wingdings=wingdings,zapf dingbats'; 24612 var systemStackFonts = [ 24613 '-apple-system', 24614 'Segoe UI', 24615 'Roboto', 24616 'Helvetica Neue', 24617 'sans-serif' 24618 ]; 24619 var splitFonts = function (fontFamily) { 24620 var fonts = fontFamily.split(/\s*,\s*/); 24621 return map(fonts, function (font) { 24622 return font.replace(/^['"]+|['"]+$/g, ''); 24623 }); 24624 }; 24625 var isSystemFontStack = function (fontFamily) { 24626 var matchesSystemStack = function () { 24627 var fonts = splitFonts(fontFamily.toLowerCase()); 24628 return forall(systemStackFonts, function (font) { 24629 return fonts.indexOf(font.toLowerCase()) > -1; 24630 }); 24631 }; 24632 return fontFamily.indexOf('-apple-system') === 0 && matchesSystemStack(); 24633 }; 24634 var getSpec$1 = function (editor) { 24635 var getMatchingValue = function () { 24636 var getFirstFont = function (fontFamily) { 24637 return fontFamily ? splitFonts(fontFamily)[0] : ''; 24638 }; 24639 var fontFamily = editor.queryCommandValue('FontName'); 24640 var items = dataset.data; 24641 var font = fontFamily ? fontFamily.toLowerCase() : ''; 24642 var matchOpt = find(items, function (item) { 24643 var format = item.format; 24644 return format.toLowerCase() === font || getFirstFont(format).toLowerCase() === getFirstFont(font).toLowerCase(); 24645 }).orThunk(function () { 24646 if (isSystemFontStack(font)) { 24647 return Optional.from({ 24648 title: 'System Font', 24649 format: font 24650 }); 24651 } else { 24652 return Optional.none(); 24653 } 24654 }); 24655 return { 24656 matchOpt: matchOpt, 24657 font: fontFamily 24658 }; 24659 }; 24660 var isSelectedFor = function (item) { 24661 return function (valueOpt) { 24662 return valueOpt.exists(function (value) { 24663 return value.format === item; 24664 }); 24665 }; 24666 }; 24667 var getCurrentValue = function () { 24668 var matchOpt = getMatchingValue().matchOpt; 24669 return matchOpt; 24670 }; 24671 var getPreviewFor = function (item) { 24672 return function () { 24673 return Optional.some({ 24674 tag: 'div', 24675 styles: item.indexOf('dings') === -1 ? { 'font-family': item } : {} 24676 }); 24677 }; 24678 }; 24679 var onAction = function (rawItem) { 24680 return function () { 24681 editor.undoManager.transact(function () { 24682 editor.focus(); 24683 editor.execCommand('FontName', false, rawItem.format); 24684 }); 24685 }; 24686 }; 24687 var updateSelectMenuText = function (comp) { 24688 var _a = getMatchingValue(), matchOpt = _a.matchOpt, font = _a.font; 24689 var text = matchOpt.fold(function () { 24690 return font; 24691 }, function (item) { 24692 return item.title; 24693 }); 24694 emitWith(comp, updateMenuText, { text: text }); 24695 }; 24696 var dataset = buildBasicSettingsDataset(editor, 'font_formats', defaultFontsFormats, Delimiter.SemiColon); 24697 return { 24698 tooltip: 'Fonts', 24699 icon: Optional.none(), 24700 isSelectedFor: isSelectedFor, 24701 getCurrentValue: getCurrentValue, 24702 getPreviewFor: getPreviewFor, 24703 onAction: onAction, 24704 updateText: updateSelectMenuText, 24705 dataset: dataset, 24706 shouldHide: false, 24707 isInvalid: never 24708 }; 24709 }; 24710 var createFontSelect = function (editor, backstage) { 24711 return createSelectButton(editor, backstage, getSpec$1(editor)); 24712 }; 24713 var fontSelectMenu = function (editor, backstage) { 24714 var menuItems = createMenuItems(editor, backstage, getSpec$1(editor)); 24715 editor.ui.registry.addNestedMenuItem('fontformats', { 24716 text: backstage.shared.providers.translate('Fonts'), 24717 getSubmenuItems: function () {
24718 return menuItems.items.validateItems(menuItems.getStyleItems()); 24719 } 24720 }); 24721 }; 24722 24723 var defaultFontsizeFormats = '8pt 10pt 12pt 14pt 18pt 24pt 36pt'; 24724 var legacyFontSizes = { 24725 '8pt': '1', 24726 '10pt': '2', 24727 '12pt': '3', 24728 '14pt': '4', 24729 '18pt': '5', 24730 '24pt': '6', 24731 '36pt': '7' 24732 }; 24733 var keywordFontSizes = { 24734 'xx-small': '7pt', 24735 'x-small': '8pt', 24736 'small': '10pt', 24737 'medium': '12pt', 24738 'large': '14pt', 24739 'x-large': '18pt', 24740 'xx-large': '24pt' 24741 }; 24742 var round$1 = function (number, precision) { 24743 var factor = Math.pow(10, precision); 24744 return Math.round(number * factor) / factor; 24745 }; 24746 var toPt = function (fontSize, precision) { 24747 if (/[0-9.]+px$/.test(fontSize)) { 24748 return round$1(parseInt(fontSize, 10) * 72 / 96, precision || 0) + 'pt'; 24749 } else { 24750 return get$1(keywordFontSizes, fontSize).getOr(fontSize); 24751 } 24752 }; 24753 var toLegacy = function (fontSize) { 24754 return get$1(legacyFontSizes, fontSize).getOr(''); 24755 }; 24756 var getSpec$2 = function (editor) { 24757 var getMatchingValue = function () { 24758 var matchOpt = Optional.none(); 24759 var items = dataset.data; 24760 var fontSize = editor.queryCommandValue('FontSize'); 24761 if (fontSize) { 24762 var _loop_1 = function (precision) { 24763 var pt = toPt(fontSize, precision); 24764 var legacy = toLegacy(pt); 24765 matchOpt = find(items, function (item) { 24766 return item.format === fontSize || item.format === pt || item.format === legacy; 24767 }); 24768 }; 24769 for (var precision = 3; matchOpt.isNone() && precision >= 0; precision--) { 24770 _loop_1(precision); 24771 } 24772 } 24773 return { 24774 matchOpt: matchOpt, 24775 size: fontSize 24776 }; 24777 }; 24778 var isSelectedFor = function (item) { 24779 return function (valueOpt) { 24780 return valueOpt.exists(function (value) { 24781 return value.format === item; 24782 }); 24783 }; 24784 }; 24785 var getCurrentValue = function () { 24786 var matchOpt = getMatchingValue().matchOpt; 24787 return matchOpt; 24788 }; 24789 var getPreviewFor = constant(Optional.none); 24790 var onAction = function (rawItem) { 24791 return function () { 24792 editor.undoManager.transact(function () { 24793 editor.focus(); 24794 editor.execCommand('FontSize', false, rawItem.format); 24795 }); 24796 }; 24797 }; 24798 var updateSelectMenuText = function (comp) { 24799 var _a = getMatchingValue(), matchOpt = _a.matchOpt, size = _a.size; 24800 var text = matchOpt.fold(function () { 24801 return size; 24802 }, function (match) { 24803 return match.title; 24804 }); 24805 emitWith(comp, updateMenuText, { text: text }); 24806 }; 24807 var dataset = buildBasicSettingsDataset(editor, 'fontsize_formats', defaultFontsizeFormats, Delimiter.Space); 24808 return { 24809 tooltip: 'Font sizes', 24810 icon: Optional.none(), 24811 isSelectedFor: isSelectedFor, 24812 getPreviewFor: getPreviewFor, 24813 getCurrentValue: getCurrentValue, 24814 onAction: onAction, 24815 updateText: updateSelectMenuText, 24816 dataset: dataset, 24817 shouldHide: false, 24818 isInvalid: never 24819 }; 24820 }; 24821 var createFontsizeSelect = function (editor, backstage) { 24822 return createSelectButton(editor, backstage, getSpec$2(editor)); 24823 }; 24824 var fontsizeSelectMenu = function (editor, backstage) { 24825 var menuItems = createMenuItems(editor, backstage, getSpec$2(editor)); 24826 editor.ui.registry.addNestedMenuItem('fontsizes', { 24827 text: 'Font sizes', 24828 getSubmenuItems: function () { 24829 return menuItems.items.validateItems(menuItems.getStyleItems()); 24830 } 24831 }); 24832 }; 24833 24834 var findNearest = function (editor, getStyles) { 24835 var styles = getStyles(); 24836 var formats = map(styles, function (style) { 24837 return style.format; 24838 }); 24839 return Optional.from(editor.formatter.closest(formats)).bind(function (fmt) { 24840 return find(styles, function (data) { 24841 return data.format === fmt; 24842 }); 24843 }).orThunk(function () { 24844 return someIf(editor.formatter.match('p'), { 24845 title: 'Paragraph', 24846 format: 'p' 24847 }); 24848 }); 24849 }; 24850 24851 var revocable = function (doRevoke) { 24852 var subject = Cell(Optional.none()); 24853 var revoke = function () { 24854 return subject.get().each(doRevoke); 24855 }; 24856 var clear = function () { 24857 revoke(); 24858 subject.set(Optional.none()); 24859 }; 24860 var isSet = function () { 24861 return subject.get().isSome(); 24862 }; 24863 var set = function (s) { 24864 revoke(); 24865 subject.set(Optional.some(s)); 24866 }; 24867 return { 24868 clear: clear, 24869 isSet: isSet, 24870 set: set 24871 }; 24872 }; 24873 var destroyable = function () { 24874 return revocable(function (s) { 24875 return s.destroy(); 24876 }); 24877 }; 24878 var unbindable = function () { 24879 return revocable(function (s) { 24880 return s.unbind(); 24881 }); 24882 }; 24883 var value$3 = function () { 24884 var subject = Cell(Optional.none()); 24885 var clear = function () { 24886 return subject.set(Optional.none()); 24887 }; 24888 var set = function (s) { 24889 return subject.set(Optional.some(s)); 24890 }; 24891 var isSet = function () { 24892 return subject.get().isSome(); 24893 }; 24894 var on = function (f) { 24895 return subject.get().each(f); 24896 }; 24897 return { 24898 clear: clear, 24899 set: set, 24900 isSet: isSet, 24901 on: on 24902 }; 24903 }; 24904 24905 var onSetupFormatToggle = function (editor, name) { 24906 return function (api) { 24907 var boundCallback = unbindable(); 24908 var init = function () { 24909 api.setActive(editor.formatter.match(name)); 24910 var binding = editor.formatter.formatChanged(name, api.setActive); 24911 boundCallback.set(binding); 24912 }; 24913 editor.initialized ? init() : editor.on('init', init); 24914 return boundCallback.clear; 24915 }; 24916 }; 24917 var onActionToggleFormat = function (editor) { 24918 return function (rawItem) { 24919 return function () { 24920 editor.undoManager.transact(function () { 24921 editor.focus(); 24922 editor.execCommand('mceToggleFormat', false, rawItem.format); 24923 }); 24924 }; 24925 }; 24926 }; 24927 24928 var defaultBlocks = 'Paragraph=p;' + 'Heading 1=h1;' + 'Heading 2=h2;' + 'Heading 3=h3;' + 'Heading 4=h4;' + 'Heading 5=h5;' + 'Heading 6=h6;' + 'Preformatted=pre'; 24929 var getSpec$3 = function (editor) { 24930 var isSelectedFor = function (format) { 24931 return function () { 24932 return editor.formatter.match(format); 24933 }; 24934 }; 24935 var getPreviewFor = function (format) { 24936 return function () { 24937 var fmt = editor.formatter.get(format); 24938 return Optional.some({ 24939 tag: fmt.length > 0 ? fmt[0].inline || fmt[0].block || 'div' : 'div', 24940 styles: editor.dom.parseStyle(editor.formatter.getCssText(format)) 24941 }); 24942 }; 24943 }; 24944 var updateSelectMenuText = function (comp) { 24945 var detectedFormat = findNearest(editor, function () { 24946 return dataset.data; 24947 }); 24948 var text = detectedFormat.fold(function () { 24949 return 'Paragraph'; 24950 }, function (fmt) { 24951 return fmt.title; 24952 }); 24953 emitWith(comp, updateMenuText, { text: text }); 24954 }; 24955 var dataset = buildBasicSettingsDataset(editor, 'block_formats', defaultBlocks, Delimiter.SemiColon); 24956 return { 24957 tooltip: 'Blocks', 24958 icon: Optional.none(), 24959 isSelectedFor: isSelectedFor, 24960 getCurrentValue: Optional.none, 24961 getPreviewFor: getPreviewFor, 24962 onAction: onActionToggleFormat(editor), 24963 updateText: updateSelectMenuText, 24964 dataset: dataset, 24965 shouldHide: false, 24966 isInvalid: function (item) { 24967 return !editor.formatter.canApply(item.format); 24968 } 24969 }; 24970 }; 24971 var createFormatSelect = function (editor, backstage) { 24972 return createSelectButton(editor, backstage, getSpec$3(editor)); 24973 }; 24974 var formatSelectMenu = function (editor, backstage) { 24975 var menuItems = createMenuItems(editor, backstage, getSpec$3(editor)); 24976 editor.ui.registry.addNestedMenuItem('blockformats', { 24977 text: 'Blocks', 24978 getSubmenuItems: function () {
24979 return menuItems.items.validateItems(menuItems.getStyleItems()); 24980 } 24981 }); 24982 }; 24983 24984 var getSpec$4 = function (editor, dataset) { 24985 var isSelectedFor = function (format) { 24986 return function () { 24987 return editor.formatter.match(format); 24988 }; 24989 }; 24990 var getPreviewFor = function (format) { 24991 return function () { 24992 var fmt = editor.formatter.get(format); 24993 return fmt !== undefined ? Optional.some({ 24994 tag: fmt.length > 0 ? fmt[0].inline || fmt[0].block || 'div' : 'div', 24995 styles: editor.dom.parseStyle(editor.formatter.getCssText(format)) 24996 }) : Optional.none(); 24997 }; 24998 }; 24999 var updateSelectMenuText = function (comp) { 25000 var getFormatItems = function (fmt) { 25001 var subs = fmt.items; 25002 return subs !== undefined && subs.length > 0 ? bind(subs, getFormatItems) : [{ 25003 title: fmt.title, 25004 format: fmt.format 25005 }]; 25006 }; 25007 var flattenedItems = bind(getStyleFormats(editor), getFormatItems); 25008 var detectedFormat = findNearest(editor, function () { 25009 return flattenedItems; 25010 }); 25011 var text = detectedFormat.fold(function () { 25012 return 'Paragraph'; 25013 }, function (fmt) { 25014 return fmt.title; 25015 }); 25016 emitWith(comp, updateMenuText, { text: text }); 25017 }; 25018 return { 25019 tooltip: 'Formats', 25020 icon: Optional.none(), 25021 isSelectedFor: isSelectedFor, 25022 getCurrentValue: Optional.none, 25023 getPreviewFor: getPreviewFor, 25024 onAction: onActionToggleFormat(editor), 25025 updateText: updateSelectMenuText, 25026 shouldHide: editor.getParam('style_formats_autohide', false, 'boolean'), 25027 isInvalid: function (item) { 25028 return !editor.formatter.canApply(item.format); 25029 }, 25030 dataset: dataset 25031 }; 25032 }; 25033 var createStyleSelect = function (editor, backstage) { 25034 var dataset = __assign({ type: 'advanced' }, backstage.styleselect); 25035 return createSelectButton(editor, backstage, getSpec$4(editor, dataset)); 25036 }; 25037 var styleSelectMenu = function (editor, backstage) { 25038 var dataset = __assign({ type: 'advanced' }, backstage.styleselect); 25039 var menuItems = createMenuItems(editor, backstage, getSpec$4(editor, dataset)); 25040 editor.ui.registry.addNestedMenuItem('formats', { 25041 text: 'Formats', 25042 getSubmenuItems: function () { 25043 return menuItems.items.validateItems(menuItems.getStyleItems()); 25044 } 25045 }); 25046 }; 25047 25048 var defaultToolbar = [ 25049 { 25050 name: 'history', 25051 items: [ 25052 'undo', 25053 'redo' 25054 ] 25055 }, 25056 { 25057 name: 'styles', 25058 items: ['styleselect'] 25059 }, 25060 { 25061 name: 'formatting', 25062 items: [ 25063 'bold', 25064 'italic' 25065 ] 25066 }, 25067 { 25068 name: 'alignment', 25069 items: [ 25070 'alignleft', 25071 'aligncenter', 25072 'alignright', 25073 'alignjustify' 25074 ] 25075 }, 25076 { 25077 name: 'indentation', 25078 items: [ 25079 'outdent', 25080 'indent' 25081 ] 25082 }, 25083 { 25084 name: 'permanent pen', 25085 items: ['permanentpen'] 25086 }, 25087 { 25088 name: 'comments', 25089 items: ['addcomment'] 25090 } 25091 ]; 25092 var renderFromBridge = function (bridgeBuilder, render) { 25093 return function (spec, extras, editor) { 25094 var internal = bridgeBuilder(spec).mapError(function (errInfo) { 25095 return formatError(errInfo); 25096 }).getOrDie(); 25097 return render(internal, extras, editor); 25098 }; 25099 }; 25100 var types = { 25101 button: renderFromBridge(createToolbarButton, function (s, extras) { 25102 return renderToolbarButton(s, extras.backstage.shared.providers); 25103 }), 25104 togglebutton: renderFromBridge(createToggleButton, function (s, extras) { 25105 return renderToolbarToggleButton(s, extras.backstage.shared.providers); 25106 }), 25107 menubutton: renderFromBridge(createMenuButton, function (s, extras) { 25108 return renderMenuButton(s, 'tox-tbtn', extras.backstage, Optional.none()); 25109 }), 25110 splitbutton: renderFromBridge(createSplitButton, function (s, extras) { 25111 return renderSplitButton(s, extras.backstage.shared); 25112 }), 25113 grouptoolbarbutton: renderFromBridge(createGroupToolbarButton, function (s, extras, editor) { 25114 var _a; 25115 var buttons = editor.ui.registry.getAll().buttons; 25116 var identify = function (toolbar) { 25117 return identifyButtons(editor, { 25118 buttons: buttons, 25119 toolbar: toolbar, 25120 allowToolbarGroups: false 25121 }, extras, Optional.none()); 25122 }; 25123 var attributes = (_a = {}, _a[Attribute] = extras.backstage.shared.header.isPositionedAtTop() ? AttributeValue.TopToBottom : AttributeValue.BottomToTop, _a); 25124 switch (getToolbarMode(editor)) { 25125 case ToolbarMode.floating: 25126 return renderFloatingToolbarButton(s, extras.backstage, identify, attributes); 25127 default: 25128 throw new Error('Toolbar groups are only supported when using floating toolbar mode'); 25129 } 25130 }), 25131 styleSelectButton: function (editor, extras) { 25132 return createStyleSelect(editor, extras.backstage); 25133 }, 25134 fontsizeSelectButton: function (editor, extras) { 25135 return createFontsizeSelect(editor, extras.backstage); 25136 }, 25137 fontSelectButton: function (editor, extras) { 25138 return createFontSelect(editor, extras.backstage); 25139 }, 25140 formatButton: function (editor, extras) { 25141 return createFormatSelect(editor, extras.backstage); 25142 }, 25143 alignMenuButton: function (editor, extras) { 25144 return createAlignSelect(editor, extras.backstage); 25145 } 25146 }; 25147 var extractFrom = function (spec, extras, editor) { 25148 return get$1(types, spec.type).fold(function () { 25149 console.error('skipping button defined by', spec); 25150 return Optional.none(); 25151 }, function (render) { 25152 return Optional.some(render(spec, extras, editor)); 25153 }); 25154 }; 25155 var bespokeButtons = { 25156 styleselect: types.styleSelectButton, 25157 fontsizeselect: types.fontsizeSelectButton, 25158 fontselect: types.fontSelectButton, 25159 formatselect: types.formatButton, 25160 align: types.alignMenuButton 25161 }; 25162 var removeUnusedDefaults = function (buttons) { 25163 var filteredItemGroups = map(defaultToolbar, function (group) { 25164 var items = filter(group.items, function (subItem) { 25165 return has(buttons, subItem) || has(bespokeButtons, subItem); 25166 }); 25167 return { 25168 name: group.name, 25169 items: items 25170 }; 25171 }); 25172 return filter(filteredItemGroups, function (group) { 25173 return group.items.length > 0; 25174 }); 25175 }; 25176 var convertStringToolbar = function (strToolbar) { 25177 var groupsStrings = strToolbar.split('|'); 25178 return map(groupsStrings, function (g) { 25179 return { items: g.trim().split(' ') }; 25180 }); 25181 }; 25182 var isToolbarGroupSettingArray = function (toolbar) { 25183 return isArrayOf(toolbar, function (t) { 25184 return has(t, 'name') && has(t, 'items'); 25185 }); 25186 }; 25187 var createToolbar = function (toolbarConfig) { 25188 var toolbar = toolbarConfig.toolbar; 25189 var buttons = toolbarConfig.buttons; 25190 if (toolbar === false) { 25191 return []; 25192 } else if (toolbar === undefined || toolbar === true) { 25193 return removeUnusedDefaults(buttons); 25194 } else if (isString(toolbar)) { 25195 return convertStringToolbar(toolbar); 25196 } else if (isToolbarGroupSettingArray(toolbar)) { 25197 return toolbar; 25198 } else { 25199 console.error('Toolbar type should be string, string[], boolean or ToolbarGroup[]'); 25200 return []; 25201 } 25202 }; 25203 var lookupButton = function (editor, buttons, toolbarItem, allowToolbarGroups, extras, prefixes) { 25204 return get$1(buttons, toolbarItem.toLowerCase()).orThunk(function () { 25205 return prefixes.bind(function (ps) { 25206 return findMap(ps, function (prefix) { 25207 return get$1(buttons, prefix + toolbarItem.toLowerCase()); 25208 }); 25209 }); 25210 }).fold(function () { 25211 return get$1(bespokeButtons, toolbarItem.toLowerCase()).map(function (r) { 25212 return r(editor, extras); 25213 }).orThunk(function () { 25214 return Optional.none(); 25215 }); 25216 }, function (spec) { 25217 if (spec.type === 'grouptoolbarbutton' && !allowToolbarGroups) { 25218 console.warn('Ignoring the \'' + toolbarItem + '\' toolbar button. Group toolbar buttons are only supported when using floating toolbar mode and cannot be nested.'); 25219 return Optional.none(); 25220 } else { 25221 return extractFrom(spec, extras, editor); 25222 } 25223 }); 25224 }; 25225 var identifyButtons = function (editor, toolbarConfig, extras, prefixes) { 25226 var toolbarGroups = createToolbar(toolbarConfig); 25227 var groups = map(toolbarGroups, function (group) { 25228 var items = bind(group.items, function (toolbarItem) { 25229 return toolbarItem.trim().length === 0 ? [] : lookupButton(editor, toolbarConfig.buttons, toolbarItem, toolbarConfig.allowToolbarGroups, extras, prefixes).toArray(); 25230 }); 25231 return { 25232 title: Optional.from(editor.translate(group.name)), 25233 items: items 25234 }; 25235 }); 25236 return filter(groups, function (group) { 25237 return group.items.length > 0; 25238 }); 25239 }; 25240 25241 var bubbleSize = 12; 25242 var bubbleAlignments$1 = { 25243 valignCentre: [], 25244 alignCentre: [], 25245 alignLeft: ['tox-pop--align-left'], 25246 alignRight: ['tox-pop--align-right'], 25247 right: ['tox-pop--right'], 25248 left: ['tox-pop--left'], 25249 bottom: ['tox-pop--bottom'], 25250 top: ['tox-pop--top'] 25251 }; 25252 var anchorOverrides = { 25253 maxHeightFunction: expandable(), 25254 maxWidthFunction: expandable$1() 25255 }; 25256 var desktopAnchorSpecLayouts = { 25257 onLtr: function () { 25258 return [ 25259 north$1, 25260 south$1, 25261 northeast$1, 25262 southeast$1, 25263 northwest$1, 25264 southwest$1, 25265 north$3, 25266 south$3, 25267 northeast$3, 25268 southeast$3, 25269 northwest$3, 25270 southwest$3 25271 ]; 25272 }, 25273 onRtl: function () { 25274 return [ 25275 north$1, 25276 south$1, 25277 northwest$1, 25278 southwest$1, 25279 northeast$1, 25280 southeast$1, 25281 north$3, 25282 south$3, 25283 northwest$3, 25284 southwest$3, 25285 northeast$3, 25286 southeast$3 25287 ]; 25288 } 25289 }; 25290 var mobileAnchorSpecLayouts = { 25291 onLtr: function () { 25292 return [ 25293 south$1, 25294 southeast$1, 25295 southwest$1, 25296 northeast$1, 25297 northwest$1, 25298 north$1, 25299 north$3, 25300 south$3, 25301 northeast$3, 25302 southeast$3, 25303 northwest$3, 25304 southwest$3 25305 ]; 25306 }, 25307 onRtl: function () { 25308 return [ 25309 south$1, 25310 southwest$1, 25311 southeast$1, 25312 northwest$1, 25313 northeast$1, 25314 north$1, 25315 north$3, 25316 south$3, 25317 northwest$3, 25318 southwest$3, 25319 northeast$3, 25320 southeast$3 25321 ]; 25322 } 25323 }; 25324 var getAnchorLayout = function (position, isTouch) { 25325 if (position === 'line') { 25326 return { 25327 bubble: nu$8(bubbleSize, 0, bubbleAlignments$1), 25328 layouts: { 25329 onLtr: function () { 25330 return [east$1]; 25331 }, 25332 onRtl: function () { 25333 return [west$1]; 25334 } 25335 }, 25336 overrides: anchorOverrides 25337 }; 25338 } else { 25339 return { 25340 bubble: nu$8(0, bubbleSize, bubbleAlignments$1), 25341 layouts: isTouch ? mobileAnchorSpecLayouts : desktopAnchorSpecLayouts, 25342 overrides: anchorOverrides 25343 }; 25344 } 25345 }; 25346 var register$4 = function (editor, registryContextToolbars, sink, extras) { 25347 var isTouch = detect$3().deviceType.isTouch; 25348 var contextbar = build$1(renderContextToolbar({ 25349 sink: sink, 25350 onEscape: function () { 25351 editor.focus(); 25352 return Optional.some(true); 25353 } 25354 })); 25355 var getBounds = function () { 25356 return getContextToolbarBounds(editor, extras.backstage.shared); 25357 }; 25358 var isRangeOverlapping = function (aTop, aBottom, bTop, bBottom) { 25359 return Math.max(aTop, bTop) <= Math.min(aBottom, bBottom); 25360 }; 25361 var getLastElementVerticalBound = function () { 25362 var nodeBounds = lastElement.get().filter(function (ele) { 25363 return inBody(SugarElement.fromDom(ele)); 25364 }).map(function (ele) { 25365 return ele.getBoundingClientRect(); 25366 }).getOrThunk(function () { 25367 return editor.selection.getRng().getBoundingClientRect(); 25368 }); 25369 var diffTop = editor.inline ? get$9().top : absolute$1(SugarElement.fromDom(editor.getBody())).y; 25370 return { 25371 y: nodeBounds.top + diffTop, 25372 bottom: nodeBounds.bottom + diffTop 25373 }; 25374 }; 25375 var shouldContextToolbarHide = function () { 25376 if (isTouch() && extras.backstage.isContextMenuOpen()) { 25377 return true; 25378 } 25379 var lastElementBounds = getLastElementVerticalBound(); 25380 var contextToolbarBounds = getBounds(); 25381 return !isRangeOverlapping(lastElementBounds.y, lastElementBounds.bottom, contextToolbarBounds.y, contextToolbarBounds.bottom); 25382 }; 25383 var close = function () { 25384 lastAnchor.set(Optional.none()); 25385 InlineView.hide(contextbar); 25386 }; 25387 var forceHide = function () { 25388 InlineView.hide(contextbar); 25389 }; 25390 var hideOrRepositionIfNecessary = function () { 25391 lastAnchor.get().each(function (anchor) { 25392 var contextBarEle = contextbar.element; 25393 remove$6(contextBarEle, 'display'); 25394 if (shouldContextToolbarHide()) { 25395 set$2(contextBarEle, 'display', 'none'); 25396 } else { 25397 Positioning.positionWithinBounds(sink, anchor, contextbar, Optional.some(getBounds())); 25398 } 25399 }); 25400 }; 25401 var lastAnchor = Cell(Optional.none()); 25402 var lastElement = Cell(Optional.none()); 25403 var timer = Cell(null); 25404 var wrapInPopDialog = function (toolbarSpec) { 25405 return { 25406 dom: { 25407 tag: 'div', 25408 classes: ['tox-pop__dialog'] 25409 }, 25410 components: [toolbarSpec], 25411 behaviours: derive$1([ 25412 Keying.config({ mode: 'acyclic' }), 25413 config('pop-dialog-wrap-events', [ 25414 runOnAttached(function (comp) { 25415 editor.shortcuts.add('ctrl+F9', 'focus statusbar', function () { 25416 return Keying.focusIn(comp); 25417 }); 25418 }), 25419 runOnDetached(function (_comp) { 25420 editor.shortcuts.remove('ctrl+F9'); 25421 }) 25422 ]) 25423 ]) 25424 }; 25425 }; 25426 var getScopes = cached(function () { 25427 return categorise(registryContextToolbars, function (toolbarApi) { 25428 var alloySpec = buildToolbar([toolbarApi]); 25429 emitWith(contextbar, forwardSlideEvent, { forwardContents: wrapInPopDialog(alloySpec) }); 25430 }); 25431 }); 25432 var buildContextToolbarGroups = function (allButtons, ctx) { 25433 return identifyButtons(editor, { 25434 buttons: allButtons, 25435 toolbar: ctx.items, 25436 allowToolbarGroups: false 25437 }, extras, Optional.some(['form:'])); 25438 }; 25439 var buildContextMenuGroups = function (ctx, providers) { 25440 return ContextForm.buildInitGroups(ctx, providers); 25441 }; 25442 var buildToolbar = function (toolbars) { 25443 var buttons = editor.ui.registry.getAll().buttons; 25444 var scopes = getScopes(); 25445 var allButtons = __assign(__assign({}, buttons), scopes.formNavigators); 25446 var toolbarType = getToolbarMode(editor) === ToolbarMode.scrolling ? ToolbarMode.scrolling : ToolbarMode.default; 25447 var initGroups = flatten(map(toolbars, function (ctx) { 25448 return ctx.type === 'contexttoolbar' ? buildContextToolbarGroups(allButtons, ctx) : buildContextMenuGroups(ctx, extras.backstage.shared.providers); 25449 })); 25450 return renderToolbar({ 25451 type: toolbarType, 25452 uid: generate$1('context-toolbar'), 25453 initGroups: i
25453nitGroups, 25454 onEscape: Optional.none, 25455 cyclicKeying: true, 25456 providers: extras.backstage.shared.providers 25457 }); 25458 }; 25459 editor.on(showContextToolbarEvent, function (e) { 25460 var scopes = getScopes(); 25461 get$1(scopes.lookupTable, e.toolbarKey).each(function (ctx) { 25462 launchContext([ctx], e.target === editor ? Optional.none() : Optional.some(e)); 25463 InlineView.getContent(contextbar).each(Keying.focusIn); 25464 }); 25465 }); 25466 var getAnchor = function (position, element) { 25467 var anchorage = position === 'node' ? extras.backstage.shared.anchors.node(element) : extras.backstage.shared.anchors.cursor(); 25468 return deepMerge(anchorage, getAnchorLayout(position, isTouch())); 25469 }; 25470 var launchContext = function (toolbarApi, elem) { 25471 clearTimer(); 25472 if (isTouch() && extras.backstage.isContextMenuOpen()) { 25473 return; 25474 } 25475 var toolbarSpec = buildToolbar(toolbarApi); 25476 var sElem = elem.map(SugarElement.fromDom); 25477 var anchor = getAnchor(toolbarApi[0].position, sElem); 25478 lastAnchor.set(Optional.some(anchor)); 25479 lastElement.set(elem); 25480 var contextBarEle = contextbar.element; 25481 remove$6(contextBarEle, 'display'); 25482 InlineView.showWithinBounds(contextbar, anchor, wrapInPopDialog(toolbarSpec), function () { 25483 return Optional.some(getBounds()); 25484 }); 25485 if (shouldContextToolbarHide()) { 25486 set$2(contextBarEle, 'display', 'none'); 25487 } 25488 }; 25489 var launchContextToolbar = function () { 25490 if (!editor.hasFocus()) { 25491 return; 25492 } 25493 var scopes = getScopes(); 25494 lookup$1(scopes, editor).fold(close, function (info) { 25495 launchContext(info.toolbars, Optional.some(info.elem.dom)); 25496 }); 25497 }; 25498 var clearTimer = function () { 25499 var current = timer.get(); 25500 if (current !== null) { 25501 global$2.clearTimeout(current); 25502 timer.set(null); 25503 } 25504 }; 25505 var asyncOpen = function () { 25506 clearTimer(); 25507 timer.set(global$2.setEditorTimeout(editor, launchContextToolbar, 0)); 25508 }; 25509 editor.on('init', function () { 25510 editor.on(hideContextToolbarEvent, forceHide); 25511 editor.on('ScrollContent ScrollWindow longpress', hideOrRepositionIfNecessary); 25512 editor.on('click keyup focus SetContent ObjectResized ResizeEditor', function () { 25513 asyncOpen(); 25514 }); 25515 editor.on('focusout', function (_e) { 25516 global$2.setEditorTimeout(editor, function () { 25517 if (search(sink.element).isNone() && search(contextbar.element).isNone()) { 25518 close(); 25519 } 25520 }, 0); 25521 }); 25522 editor.on('SwitchMode', function () { 25523 if (editor.mode.isReadOnly()) { 25524 close(); 25525 } 25526 }); 25527 editor.on('AfterProgressState', function (event) { 25528 if (event.state) { 25529 close(); 25530 } else if (editor.hasFocus()) { 25531 asyncOpen(); 25532 } 25533 }); 25534 editor.on('NodeChange', function (_e) { 25535 search(contextbar.element).fold(asyncOpen, noop); 25536 }); 25537 }); 25538 }; 25539 25540 var setup$3 = function (editor, mothership, uiMothership) { 25541 var broadcastEvent = function (name, evt) { 25542 each([ 25543 mothership, 25544 uiMothership 25545 ], function (ship) { 25546 ship.broadcastEvent(name, evt); 25547 }); 25548 }; 25549 var broadcastOn = function (channel, message) { 25550 each([ 25551 mothership, 25552 uiMothership 25553 ], function (ship) { 25554 ship.broadcastOn([channel], message); 25555 }); 25556 }; 25557 var fireDismissPopups = function (evt) { 25558 return broadcastOn(dismissPopups(), { target: evt.target }); 25559 }; 25560 var onTouchstart = bind$3(SugarElement.fromDom(document), 'touchstart', fireDismissPopups); 25561 var onTouchmove = bind$3(SugarElement.fromDom(document), 'touchmove', function (evt) { 25562 return broadcastEvent(documentTouchmove(), evt); 25563 }); 25564 var onTouchend = bind$3(SugarElement.fromDom(document), 'touchend', function (evt) { 25565 return broadcastEvent(documentTouchend(), evt); 25566 }); 25567 var onMousedown = bind$3(SugarElement.fromDom(document), 'mousedown', fireDismissPopups); 25568 var onMouseup = bind$3(SugarElement.fromDom(document), 'mouseup', function (evt) { 25569 if (evt.raw.button === 0) { 25570 broadcastOn(mouseReleased(), { target: evt.target }); 25571 } 25572 }); 25573 var onContentClick = function (raw) { 25574 return broadcastOn(dismissPopups(), { target: SugarElement.fromDom(raw.target) }); 25575 }; 25576 var onContentMouseup = function (raw) { 25577 if (raw.button === 0) { 25578 broadcastOn(mouseReleased(), { target: SugarElement.fromDom(raw.target) }); 25579 } 25580 }; 25581 var onWindowScroll = function (evt) { 25582 return broadcastEvent(windowScroll(), fromRawEvent$1(evt)); 25583 }; 25584 var onWindowResize = function (evt) { 25585 broadcastOn(repositionPopups(), {}); 25586 broadcastEvent(windowResize(), fromRawEvent$1(evt)); 25587 }; 25588 var onEditorResize = function () { 25589 return broadcastOn(repositionPopups(), {}); 25590 }; 25591 var onEditorProgress = function (evt) { 25592 if (evt.state) { 25593 broadcastOn(dismissPopups(), { target: SugarElement.fromDom(editor.getContainer()) }); 25594 } 25595 }; 25596 editor.on('PostRender', function () { 25597 editor.on('click', onContentClick); 25598 editor.on('tap', onContentClick); 25599 editor.on('mouseup', onContentMouseup); 25600 editor.on('ScrollWindow', onWindowScroll); 25601 editor.on('ResizeWindow', onWindowResize); 25602 editor.on('ResizeEditor', onEditorResize); 25603 editor.on('AfterProgressState', onEditorProgress); 25604 }); 25605 editor.on('remove', function () { 25606 editor.off('click', onContentClick); 25607 editor.off('tap', onContentClick); 25608 editor.off('mouseup', onContentMouseup); 25609 editor.off('ScrollWindow', onWindowScroll); 25610 editor.off('ResizeWindow', onWindowResize); 25611 editor.off('ResizeEditor', onEditorResize); 25612 editor.off('AfterProgressState', onEditorProgress); 25613 onMousedown.unbind(); 25614 onTouchstart.unbind(); 25615 onTouchmove.unbind(); 25616 onTouchend.unbind(); 25617 onMouseup.unbind(); 25618 }); 25619 editor.on('detach', function () { 25620 detachSystem(mothership); 25621 detachSystem(uiMothership); 25622 mothership.destroy(); 25623 uiMothership.destroy(); 25624 }); 25625 }; 25626 25627 var parts$d = AlloyParts; 25628 var partType$1 = PartType; 25629 25630 var schema$r = constant([ 25631 defaulted$1('shell', false),
25632 strict$1('makeItem'), 25633 defaulted$1('setupItem', noop), 25634 SketchBehaviours.field('listBehaviours', [Replacing]) 25635 ]); 25636 var customListDetail = function () { 25637 return { behaviours: derive$1([Replacing.config({})]) }; 25638 }; 25639 var itemsPart = optional({ 25640 name: 'items', 25641 overrides: customListDetail 25642 }); 25643 var parts$e = constant([itemsPart]); 25644 var name$2 = constant('CustomList'); 25645 25646 var factory$f = function (detail, components, _spec, _external) { 25647 var setItems = function (list, items) { 25648 getListContainer(list).fold(function () { 25649 console.error('Custom List was defined to not be a shell, but no item container was specified in components'); 25650 throw new Error('Custom List was defined to not be a shell, but no item container was specified in components'); 25651 }, function (container) { 25652 var itemComps = Replacing.contents(container); 25653 var numListsRequired = items.length; 25654 var numListsToAdd = numListsRequired - itemComps.length; 25655 var itemsToAdd = numListsToAdd > 0 ? range(numListsToAdd, function () { 25656 return detail.makeItem(); 25657 }) : []; 25658 var itemsToRemove = itemComps.slice(numListsRequired); 25659 each(itemsToRemove, function (item) { 25660 return Replacing.remove(container, item); 25661 }); 25662 each(itemsToAdd, function (item) { 25663 return Replacing.append(container, item); 25664 }); 25665 var builtLists = Replacing.contents(container); 25666 each(builtLists, function (item, i) { 25667 detail.setupItem(list, item, items[i], i); 25668 }); 25669 }); 25670 }; 25671 var extra = detail.shell ? { 25672 behaviours: [Replacing.config({})], 25673 components: [] 25674 } : { 25675 behaviours: [], 25676 components: components 25677 }; 25678 var getListContainer = function (component) { 25679 return detail.shell ? Optional.some(component) : getPart(component, detail, 'items'); 25680 }; 25681 return { 25682 uid: detail.uid, 25683 dom: detail.dom, 25684 components: extra.components, 25685 behaviours: augment(detail.listBehaviours, extra.behaviours), 25686 apis: { setItems: setItems } 25687 }; 25688 }; 25689 var CustomList = composite$1({ 25690 name: name$2(), 25691 configFields: schema$r(), 25692 partFields: parts$e(), 25693 factory: factory$f, 25694 apis: { 25695 setItems: function (apis, list, items) { 25696 apis.setItems(list, items); 25697 } 25698 } 25699 }); 25700 25701 var setup$4 = noop; 25702 var isDocked = never; 25703 var getBehaviours$2 = constant([]); 25704 25705 var StaticHeader = /*#__PURE__*/Object.freeze({ 25706 __proto__: null, 25707 setup: setup$4, 25708 isDocked: isDocked, 25709 getBehaviours: getBehaviours$2 25710 }); 25711 25712 var getOffsetParent = function (element) { 25713 var isFixed = getRaw(element, 'position').is('fixed'); 25714 var offsetParent$1 = isFixed ? Optional.none() : offsetParent(element); 25715 return offsetParent$1.orThunk(function () { 25716 var marker = SugarElement.fromTag('span'); 25717 return parent(element).bind(function (parent) { 25718 append(parent, marker); 25719 var offsetParent$1 = offsetParent(marker); 25720 remove(marker); 25721 return offsetParent$1; 25722 }); 25723 }); 25724 }; 25725 var getOrigin = function (element) { 25726 return getOffsetParent(element).map(absolute).getOrThunk(function () { 25727 return SugarPosition(0, 0); 25728 }); 25729 }; 25730 25731 var morphAdt = Adt.generate([ 25732 { static: [] }, 25733 { absolute: ['positionCss'] }, 25734 { fixed: ['positionCss'] } 25735 ]); 25736 var appear = function (component, contextualInfo) { 25737 var elem = component.element; 25738 add$2(elem, contextualInfo.transitionClass); 25739 remove$4(elem, contextualInfo.fadeOutClass); 25740 add$2(elem, contextualInfo.fadeInClass); 25741 contextualInfo.onShow(component); 25742 }; 25743 var disappear = function (component, contextualInfo) { 25744 var elem = component.element; 25745 add$2(elem, contextualInfo.transitionClass); 25746 remove$4(elem, contextualInfo.fadeInClass); 25747 add$2(elem, contextualInfo.fadeOutClass); 25748 contextualInfo.onHide(component); 25749 }; 25750 var isPartiallyVisible = function (box, viewport) { 25751 return box.y < viewport.bottom && box.bottom > viewport.y; 25752 }; 25753 var isTopCompletelyVisible = function (box, viewport) { 25754 return box.y >= viewport.y; 25755 }; 25756 var isBottomCompletelyVisible = function (box, viewport) { 25757 return box.bottom <= viewport.bottom; 25758 }; 25759 var isVisibleForModes = function (modes, box, viewport) { 25760 return forall(modes, function (mode) { 25761 switch (mode) { 25762 case 'bottom': 25763 return isBottomCompletelyVisible(box, viewport); 25764 case 'top': 25765 return isTopCompletelyVisible(box, viewport); 25766 } 25767 }); 25768 }; 25769 var getPrior = function (elem, state) { 25770 return state.getInitialPosition().map(function (pos) { 25771 return bounds$1(pos.bounds.x, pos.bounds.y, get$8(elem), get$7(elem)); 25772 }); 25773 }; 25774 var storePrior = function (elem, box, state) { 25775 state.setInitialPosition(Optional.some({ 25776 style: getAllRaw(elem), 25777 position: get$5(elem, 'position') || 'static', 25778 bounds: box 25779 })); 25780 }; 25781 var revertToOriginal = function (elem, box$1, state) { 25782 return state.getInitialPosition().bind(function (position) { 25783 state.setInitialPosition(Optional.none()); 25784 switch (position.position) { 25785 case 'static': 25786 return Optional.some(morphAdt.static()); 25787 case 'absolute': 25788 var offsetBox_1 = getOffsetParent(elem).map(box).getOrThunk(function () { 25789 return box(body()); 25790 }); 25791 return Optional.some(morphAdt.absolute(NuPositionCss('absolute', get$1(position.style, 'left').map(function (_left) { 25792 return box$1.x - offsetBox_1.x; 25793 }), get$1(position.style, 'top').map(function (_top) { 25794 return box$1.y - offsetBox_1.y; 25795 }), get$1(position.style, 'right').map(function (_right) { 25796 return offsetBox_1.right - box$1.right; 25797 }), get$1(position.style, 'bottom').map(function (_bottom) { 25798 return offsetBox_1.bottom - box$1.bottom; 25799 })))); 25800 default: 25801 return Optional.none(); 25802 } 25803 }); 25804 }; 25805 var morphToOriginal = function (elem, viewport, state) { 25806 return getPrior(elem, state).filter(function (box) { 25807 return isVisibleForModes(state.getModes(), box, viewport); 25808 }).bind(function (box) { 25809 return revertToOriginal(elem, box, state); 25810 }); 25811 }; 25812 var morphToFixed = function (elem, viewport, state) { 25813 var box$1 = box(elem); 25814 if (!isVisibleForModes(state.getModes(), box$1, viewport)) { 25815 storePrior(elem, box$1, state); 25816 var winBox = win(); 25817 var left = box$1.x - winBox.x; 25818 var top_1 = viewport.y - winBox.y; 25819 var bottom = winBox.bottom - viewport.bottom; 25820 var isTop = box$1.y <= viewport.y; 25821 return Optional.some(morphAdt.fixed(NuPositionCss('fixed', Optional.some(left), isTop ? Optional.some(top_1) : Optional.none(), Optional.none(), !isTop ? Optional.some(bottom) : Optional.none()))); 25822 } else { 25823 return Optional.none(); 25824 } 25825 }; 25826 var getMorph = function (component, viewport, state) { 25827 var elem = component.element; 25828 var isDocked = getRaw(elem, 'position').is('fixed'); 25829 return isDocked ? morphToOriginal(elem, viewport, state) : morphToFixed(elem, viewport, state); 25830 }; 25831 var getMorphToOriginal = function (component, state) { 25832 var elem = component.element; 25833 return getPrior(elem, state).bind(function (box) { 25834 return revertToOriginal(elem, box, state); 25835 }); 25836 }; 25837 25838 var morphToStatic = function (component, config) { 25839 each([ 25840 'left', 25841 'right', 25842 'top', 25843 'bottom', 25844 'position' 25845 ], function (prop) { 25846 return remove$6(component.element, prop); 25847 }); 25848 config.onUndocked(component); 25849 }; 25850 var morphToCoord = function (component, config, position) { 25851 applyPositionCss(component.element, position); 25852 var method = position.position === 'fixed' ? config.onDocked : config.onUndocked; 25853 method(component); 25854 }; 25855 var updateVisibility = function (component, config, state, viewport, morphToDocked) { 25856 if (morphToDocked === void 0) { 25857 morphToDocked = false;
25858 } 25859 config.contextual.each(function (contextInfo) { 25860 contextInfo.lazyContext(component).each(function (box) { 25861 var isVisible = isPartiallyVisible(box, viewport); 25862 if (isVisible !== state.isVisible()) { 25863 state.setVisible(isVisible); 25864 if (morphToDocked && !isVisible) { 25865 add$3(component.element, [contextInfo.fadeOutClass]); 25866 contextInfo.onHide(component); 25867 } else { 25868 var method = isVisible ? appear : disappear; 25869 method(component, contextInfo); 25870 } 25871 } 25872 }); 25873 }); 25874 }; 25875 var refreshInternal = function (component, config, state) { 25876 var viewport = config.lazyViewport(component); 25877 var isDocked = state.isDocked(); 25878 if (isDocked) { 25879 updateVisibility(component, config, state, viewport); 25880 } 25881 getMorph(component, viewport, state).each(function (morph) { 25882 state.setDocked(!isDocked); 25883 morph.fold(function () { 25884 return morphToStatic(component, config); 25885 }, function (position) { 25886 return morphToCoord(component, config, position); 25887 }, function (position) { 25888 updateVisibility(component, config, state, viewport, true); 25889 morphToCoord(component, config, position); 25890 }); 25891 }); 25892 }; 25893 var resetInternal = function (component, config, state) { 25894 var elem = component.element; 25895 state.setDocked(false); 25896 getMorphToOriginal(component, state).each(function (morph) { 25897 morph.fold(function () { 25898 return morphToStatic(component, config); 25899 }, function (position) { 25900 return morphToCoord(component, config, position); 25901 }, noop); 25902 }); 25903 state.setVisible(true); 25904 config.contextual.each(function (contextInfo) { 25905 remove$5(elem, [ 25906 contextInfo.fadeInClass, 25907 contextInfo.fadeOutClass, 25908 contextInfo.transitionClass 25909 ]); 25910 contextInfo.onShow(component); 25911 }); 25912 refresh$4(component, config, state); 25913 }; 25914 var refresh$4 = function (component, config, state) { 25915 if (component.getSystem().isConnected()) { 25916 refreshInternal(component, config, state); 25917 } 25918 }; 25919 var reset = function (component, config, state) { 25920 if (state.isDocked()) { 25921 resetInternal(component, config, state); 25922 } 25923 }; 25924 var isDocked$1 = function (component, config, state) { 25925 return state.isDocked(); 25926 }; 25927 var setModes = function (component, config, state, modes) { 25928 return state.setModes(modes); 25929 }; 25930 var getModes = function (component, config, state) { 25931 return state.getModes(); 25932 }; 25933 25934 var DockingApis = /*#__PURE__*/Object.freeze({ 25935 __proto__: null, 25936 refresh: refresh$4, 25937 reset: reset, 25938 isDocked: isDocked$1, 25939 getModes: getModes, 25940 setModes: setModes 25941 }); 25942 25943 var events$f = function (dockInfo, dockState) { 25944 return derive([ 25945 runOnSource(transitionend(), function (component, simulatedEvent) { 25946 dockInfo.contextual.each(function (contextInfo) { 25947 if (has$2(component.element, contextInfo.transitionClass)) { 25948 remove$5(component.element, [ 25949 contextInfo.transitionClass, 25950 contextInfo.fadeInClass 25951 ]); 25952 var notify = dockState.isVisible() ? contextInfo.onShown : contextInfo.onHidden; 25953 notify(component); 25954 } 25955 simulatedEvent.stop(); 25956 }); 25957 }), 25958 run(windowScroll(), function (component, _) { 25959 refresh$4(component, dockInfo, dockState); 25960 }), 25961 run(windowResize(), function (component, _) { 25962 reset(component, dockInfo, dockState); 25963 }) 25964 ]); 25965 }; 25966 25967 var ActiveDocking = /*#__PURE__*/Object.freeze({ 25968 __proto__: null, 25969 events: events$f 25970 }); 25971 25972 var DockingSchema = [ 25973 optionObjOf('contextual', [ 25974 strictString('fadeInClass'), 25975 strictString('fadeOutClass'), 25976 strictString('transitionClass'), 25977 strictFunction('lazyContext'), 25978 onHandler('onShow'), 25979 onHandler('onShown'), 25980 onHandler('onHide'), 25981 onHandler('onHidden') 25982 ]), 25983 defaultedFunction('lazyViewport', win), 25984 defaultedArrayOf('modes', [ 25985 'top', 25986 'bottom' 25987 ], string), 25988 onHandler('onDocked'), 25989 onHandler('onUndocked') 25990 ]; 25991 25992 var init$b = function (spec) { 25993 var docked = Cell(false); 25994 var visible = Cell(true); 25995 var initialBounds = Cell(Optional.none()); 25996 var modes = Cell(spec.modes); 25997 var readState = function () { 25998 return 'docked: ' + docked.get() + ', visible: ' + visible.get() + ', modes: ' + modes.get().join(','); 25999 }; 26000 return nu$5({ 26001 isDocked: docked.get, 26002 setDocked: docked.set, 26003 getInitialPosition: initialBounds.get, 26004 setInitialPosition: initialBounds.set, 26005 isVisible: visible.get, 26006 setVisible: visible.set, 26007 getModes: modes.get, 26008 setModes: modes.set, 26009 readState: readState 26010 }); 26011 }; 26012 26013 var DockingState = /*#__PURE__*/Object.freeze({ 26014 __proto__: null, 26015 init: init$b 26016 }); 26017 26018 var Docking = create$1({ 26019 fields: DockingSchema, 26020 name: 'docking', 26021 active: ActiveDocking, 26022 apis: DockingApis, 26023 state: DockingState 26024 }); 26025 26026 var visibility = { 26027 fadeInClass: 'tox-editor-dock-fadein', 26028 fadeOutClass: 'tox-editor-dock-fadeout', 26029 transitionClass: 'tox-editor-dock-transition' 26030 }; 26031 var editorStickyOnClass = 'tox-tinymce--toolbar-sticky-on'; 26032 var editorStickyOffClass = 'tox-tinymce--toolbar-sticky-off'; 26033 var scrollFromBehindHeader = function (e, containerHeader) { 26034 var doc = owner(containerHeader); 26035 var viewHeight = doc.dom.defaultView.innerHeight; 26036 var scrollPos = get$9(doc); 26037 var markerElement = SugarElement.fromDom(e.elm); 26038 var markerPos = absolute$1(markerElement); 26039 var markerHeight = get$7(markerElement); 26040 var markerTop = markerPos.y; 26041 var markerBottom = markerTop + markerHeight; 26042 var editorHeaderPos = absolute(containerHeader); 26043 var editorHeaderHeight = get$7(containerHeader); 26044 var editorHeaderTop = editorHeaderPos.top; 26045 var editorHeaderBottom = editorHeaderTop + editorHeaderHeight; 26046 var editorHeaderDockedAtTop = Math.abs(editorHeaderTop - scrollPos.top) < 2; 26047 var editorHeaderDockedAtBottom = Math.abs(editorHeaderBottom - (scrollPos.top + viewHeight)) < 2; 26048 if (editorHeaderDockedAtTop && markerTop < editorHeaderBottom) { 26049 to(scrollPos.left, markerTop - editorHeaderHeight, doc); 26050 } else if (editorHeaderDockedAtBottom && markerBottom > editorHeaderTop) { 26051 var y = markerTop - viewHeight + markerHeight + editorHeaderHeight; 26052 to(scrollPos.left, y, doc); 26053 } 26054 }; 26055 var isDockedMode = function (header, mode) { 26056 return contains(Docking.getModes(header), mode); 26057 }; 26058 var updateIframeContentFlow = function (header) { 26059 var getOccupiedHeight = function (elm) { 26060 return getOuter$1(elm) + (parseInt(get$5(elm, 'margin-top'), 10) || 0) + (parseInt(get$5(elm, 'margin-bottom'), 10) || 0); 26061 }; 26062 var elm = header.element; 26063 parent(elm).each(function (parentElem) { 26064 var padding = 'padding-' + Docking.getModes(header)[0]; 26065 if (Docking.isDocked(header)) { 26066 var parentWidth = get$8(parentElem); 26067 set$2(elm, 'width', parentWidth + 'px'); 26068 set$2(parentElem, padding, getOccupiedHeight(elm) + 'px'); 26069 } else { 26070 remove$6(elm, 'width'); 26071 remove$6(parentElem, padding); 26072 } 26073 }); 26074 }; 26075 var updateSinkVisibility = function (sinkElem, visible) { 26076 if (visible) { 26077 remove$4(sinkElem, visibility.fadeOutClass); 26078 add$3(sinkElem, [ 26079 visibility.transitionClass, 26080 visibility.fadeInClass 26081 ]); 26082 } else { 26083 remove$4(sinkElem, visibility.fadeInClass); 26084 add$3(sinkElem, [ 26085 visibility.fadeOutClass, 26086 visibility.transitionClass 26087 ]); 26088 } 26089 }; 26090 var updateEditorClasses = function (editor, docked) { 26091 var editorContainer = SugarElement.fromDom(editor.getContainer()); 26092 if (docked) { 26093 add$2(editorContainer, editorStickyOnClass); 26094 remove$4(editorContainer, editorStickyOffClass); 26095 } else { 26096 add$2(editorContainer, editorStickyOffClass); 26097 remove$4(editorContainer, editorStickyOnClass); 26098 } 26099 }; 26100 var restoreFocus = function (headerElem, focusedElem) { 26101 var ownerDoc = owner(focusedElem); 26102 active(ownerDoc).filter(function (activeElm) { 26103 return !eq$1(focusedElem, activeElm); 26104 }).filter(function (activeElm) { 26105 return eq$1(activeElm, SugarElement.fromDom(ownerDoc.dom.body)) || contains$2(headerElem, activeElm); 26106 }).each(function () { 26107 return focus$1(focusedElem); 26108 }); 26109 }; 26110 var findFocusedElem = function (rootElm, lazySink) { 26111 return search(rootElm).orThunk(function () { 26112 return lazySink().toOptional().bind(function (sink) { 26113 return search(sink.element); 26114 }); 26115 }); 26116 }; 26117 var setup$5 = function (editor, sharedBackstage, lazyHeader) { 26118 if (!editor.inline) { 26119 if (!sharedBackstage.header.isPositionedAtTop()) { 26120 editor.on('ResizeEditor', function () { 26121 lazyHeader().each(Docking.reset); 26122 }); 26123 } 26124 editor.on('ResizeWindow ResizeEditor', function () { 26125 lazyHeader().each(updateIframeContentFlow); 26126 }); 26127 editor.on('SkinLoaded', function () { 26128 lazyHeader().each(function (comp) { 26129 Docking.isDocked(comp) ? Docking.reset(comp) : Docking.refresh(comp); 26130 }); 26131 }); 26132 editor.on('FullscreenStateChanged', function () { 26133 lazyHeader().each(Docking.reset); 26134 }); 26135 } 26136 editor.on('AfterScrollIntoView', function (e) { 26137 lazyHeader().each(function (header) { 26138 Docking.refresh(header); 26139 var headerElem = header.element; 26140 if (isVisible(headerElem)) { 26141 scrollFromBehindHeader(e, headerElem); 26142 } 26143 }); 26144 }); 26145 editor.on('PostRender', function () { 26146 updateEditorClasses(editor, false); 26147 }); 26148 }; 26149 var isDocked$2 = function (lazyHeader) { 26150 return lazyHeader().map(Docking.isDocked).getOr(false); 26151 }; 26152 var getIframeBehaviours = function () { 26153 var _a; 26154 return [Receiving.config({ channels: (_a = {}, _a[toolbarHeightChange()] = { onReceive: updateIframeContentFlow }, _a) })]; 26155 }; 26156 var getBehaviours$3 = function (editor, sharedBackstage) { 26157 var focusedElm = Cell(Optional.none()); 26158 var lazySink = sharedBackstage.getSink; 26159 var runOnSinkElement = function (f) { 26160 lazySink().each(function (sink) { 26161 return f(sink.element); 26162 }); 26163 }; 26164 var onDockingSwitch = function (comp) { 26165 if (!editor.inline) { 26166 updateIframeContentFlow(comp); 26167 } 26168 updateEditorClasses(editor, Docking.isDocked(comp)); 26169 comp.getSystem().broadcastOn([repositionPopups()], {}); 26170 lazySink().each(function (sink) { 26171 return sink.getSystem().broadcastOn([repositionPopups()], {}); 26172 }); 26173 }; 26174 var additionalBehaviours = editor.inline ? [] : getIframeBehaviours(); 26175 return __spreadArrays([ 26176 Focusing.config({}), 26177 Docking.config({ 26178 contextual: __assign({ 26179 lazyContext: function (comp) { 26180 var headerHeight = getOuter$1(comp.element); 26181 var container = editor.inline ? editor.getContentAreaContainer() : editor.getContainer(); 26182 var box$1 = box(SugarElement.fromDom(container)); 26183 var boxHeight = box$1.height - headerHeight; 26184 var topBound = box$1.y + (isDockedMode(comp, 'top') ? 0 : headerHeight); 26185 return Optional.some(bounds$1(box$1.x, topBound, box$1.width, boxHeight)); 26186 }, 26187 onShow: function () { 26188 runOnSinkElement(function (elem) { 26189 return updateSinkVisibility(elem, true); 26190 }); 26191 }, 26192 onShown: function (comp) { 26193 runOnSinkElement(function (elem) { 26194 return remove$5(elem, [ 26195 visibility.transitionClass, 26196 visibility.fadeInClass 26197 ]); 26198 }); 26199 focusedElm.get().each(function (elem) { 26200 restoreFocus(comp.element, elem); 26201 focusedElm.set(Optional.none()); 26202 }); 26203 }, 26204 onHide: function (comp) { 26205 focusedElm.set(findFocusedElem(comp.element, lazySink)); 26206 runOnSinkElement(function (elem) { 26207 return updateSinkVisibility(elem, false); 26208 }); 26209 }, 26210 onHidden: function () { 26211 runOnSinkElement(function (elem) { 26212 return remove$5(elem, [visibility.transitionClass]); 26213 }); 26214 } 26215 }, visibility), 26216 modes: [sharedBackstage.header.getDockingMode()], 26217 onDocked: onDockingSwitch, 26218 onUndocked: onDockingSwitch 26219 }) 26220 ], additionalBehaviours); 26221 }; 26222 26223 var StickyHeader = /*#__PURE__*/Object.freeze({ 26224 __proto__: null, 26225 setup: setup$5, 26226 isDocked: isDocked$2, 26227 getBehaviours: getBehaviours$3 26228 }); 26229 26230 var renderHeader = function (spec) { 26231 var editor = spec.editor; 26232 var getBehaviours = spec.sticky ? getBehaviours$3 : getBehaviours$2; 26233 return { 26234 uid: spec.uid, 26235 dom: spec.dom, 26236 components: spec.components, 26237 behaviours: derive$1(getBehaviours(editor, spec.sharedBackstage)) 26238 }; 26239 }; 26240 26241 var factory$g = function (detail, spec) { 26242 var setMenus = function (comp, menus) { 26243 var newMenus = map(menus, function (m) { 26244 var buttonSpec = { 26245 type: 'menubutton', 26246 text: m.text, 26247 fetch: function (callback) { 26248 callback(m.getItems()); 26249 } 26250 }; 26251 var internal = createMenuButton(buttonSpec).mapError(function (errInfo) { 26252 return formatError(errInfo); 26253 }).getOrDie(); 26254 return renderMenuButton(internal, 'tox-mbtn', spec.backstage, Optional.some('menuitem')); 26255 }); 26256 Replacing.set(comp, newMenus); 26257 }; 26258 var apis = { 26259 focus: Keying.focusIn, 26260 setMenus: setMenus 26261 }; 26262 return { 26263 uid: detail.uid, 26264 dom: detail.dom, 26265 components: [], 26266 behaviours: derive$1([ 26267 Replacing.config({}), 26268 config('menubar-events', [ 26269 runOnAttached(function (component) { 26270 detail.onSetup(component); 26271 }), 26272 run(mouseover(), function (comp, se) { 26273 descendant$1(comp.element, '.' + 'tox-mbtn--active').each(function (activeButton) { 26274 closest$3(se.event.target, '.' + 'tox-mbtn').each(function (hoveredButton) { 26275 if (!eq$1(activeButton, hoveredButton)) { 26276 comp.getSystem().getByDom(activeButton).each(function (activeComp) { 26277 comp.getSystem().getByDom(hoveredButton).each(function (hoveredComp) { 26278 Dropdown.expand(hoveredComp); 26279 Dropdown.close(activeComp); 26280 Focusing.focus(hoveredComp); 26281 }); 26282 }); 26283 } 26284 }); 26285 }); 26286 }), 26287 run(focusShifted(), function (comp, se) { 26288 se.event.prevFocus.bind(function (prev) { 26289 return comp.getSystem().getByDom(prev).toOptional(); 26290 }).each(function (prev) { 26291 se.event.newFocus.bind(function (nu) { 26292 return comp.getSystem().getByDom(nu).toOptional(); 26293 }).each(function (nu) { 26294 if (Dropdown.isOpen(prev)) { 26295 Dropdown.expand(nu); 26296 Dropdown.close(prev); 26297 } 26298 }); 26299 }); 26300 }) 26301 ]), 26302 Keying.config({ 26303 mode: 'flow', 26304 selector: '.' + 'tox-mbtn', 26305 onEscape: function (comp) { 26306 detail.on
26306Escape(comp); 26307 return Optional.some(true); 26308 } 26309 }), 26310 Tabstopping.config({}) 26311 ]), 26312 apis: apis, 26313 domModification: { attributes: { role: 'menubar' } } 26314 }; 26315 }; 26316 var SilverMenubar = single$2({ 26317 factory: factory$g, 26318 name: 'silver.Menubar', 26319 configFields: [ 26320 strict$1('dom'), 26321 strict$1('uid'), 26322 strict$1('onEscape'), 26323 strict$1('backstage'), 26324 defaulted$1('onSetup', noop) 26325 ], 26326 apis: { 26327 focus: function (apis, comp) { 26328 apis.focus(comp); 26329 }, 26330 setMenus: function (apis, comp, menus) { 26331 apis.setMenus(comp, menus); 26332 } 26333 } 26334 }); 26335 26336 var owner$4 = 'container'; 26337 var schema$s = [field$1('slotBehaviours', [])]; 26338 var getPartName$1 = function (name) { 26339 return '<alloy.field.' + name + '>'; 26340 }; 26341 var sketch$2 = function (sSpec) { 26342 var parts = function () { 26343 var record = []; 26344 var slot = function (name, config) { 26345 record.push(name); 26346 return generateOne(owner$4, getPartName$1(name), config); 26347 }; 26348 return { 26349 slot: slot, 26350 record: function () { 26351 return record; 26352 } 26353 }; 26354 }(); 26355 var spec = sSpec(parts); 26356 var partNames = parts.record(); 26357 var fieldParts = map(partNames, function (n) { 26358 return required({ 26359 name: n, 26360 pname: getPartName$1(n) 26361 }); 26362 }); 26363 return composite(owner$4, schema$s, fieldParts, make$7, spec); 26364 }; 26365 var make$7 = function (detail, components) { 26366 var getSlotNames = function (_) { 26367 return getAllPartNames(detail); 26368 }; 26369 var getSlot = function (container, key) { 26370 return getPart(container, detail, key); 26371 }; 26372 var onSlot = function (f, def) { 26373 return function (container, key) { 26374 return getPart(container, detail, key).map(function (slot) { 26375 return f(slot, key); 26376 }).getOr(def); 26377 }; 26378 }; 26379 var onSlots = function (f) { 26380 return function (container, keys) { 26381 each(keys, function (key) { 26382 return f(container, key); 26383 }); 26384 }; 26385 }; 26386 var doShowing = function (comp, _key) { 26387 return get$3(comp.element, 'aria-hidden') !== 'true'; 26388 }; 26389 var doShow = function (comp, key) { 26390 if (!doShowing(comp)) { 26391 var element = comp.element; 26392 remove$6(element, 'display'); 26393 remove$1(element, 'aria-hidden'); 26394 emitWith(comp, slotVisibility(), { 26395 name: key, 26396 visible: true 26397 }); 26398 } 26399 }; 26400 var doHide = function (comp, key) { 26401 if (doShowing(comp)) { 26402 var element = comp.element; 26403 set$2(element, 'display', 'none'); 26404 set$1(element, 'aria-hidden', 'true'); 26405 emitWith(comp, slotVisibility(), { 26406 name: key, 26407 visible: false 26408 }); 26409 } 26410 }; 26411 var isShowing = onSlot(doShowing, false); 26412 var hideSlot = onSlot(doHide); 26413 var hideSlots = onSlots(hideSlot); 26414 var hideAllSlots = function (container) { 26415 return hideSlots(container, getSlotNames()); 26416 }; 26417 var showSlot = onSlot(doShow); 26418 var apis = { 26419 getSlotNames: getSlotNames, 26420 getSlot: getSlot, 26421 isShowing: isShowing, 26422 hideSlot: hideSlot, 26423 hideAllSlots: hideAllSlots, 26424 showSlot: showSlot 26425 }; 26426 return { 26427 uid: detail.uid, 26428 dom: detail.dom, 26429 components: components, 26430 behaviours: get$d(detail.slotBehaviours), 26431 apis: apis 26432 }; 26433 }; 26434 var slotApis = map$2({ 26435 getSlotNames: function (apis, c) { 26436 return apis.getSlotNames(c); 26437 }, 26438 getSlot: function (apis, c, key) { 26439 return apis.getSlot(c, key); 26440 }, 26441 isShowing: function (apis, c, key) { 26442 return apis.isShowing(c, key); 26443 }, 26444 hideSlot: function (apis, c, key) { 26445 return apis.hideSlot(c, key); 26446 }, 26447 hideAllSlots: function (apis, c) { 26448 return apis.hideAllSlots(c); 26449 }, 26450 showSlot: function (apis, c, key) { 26451 return apis.showSlot(c, key); 26452 } 26453 }, function (value) { 26454 return makeApi(value); 26455 }); 26456 var SlotContainer = __assign(__assign({}, slotApis), { sketch: sketch$2 }); 26457 26458 var sidebarSchema = objOf([ 26459 optionString('icon'), 26460 optionString('tooltip'), 26461 defaultedFunction('onShow', noop),
26462 defaultedFunction('onHide', noop), 26463 defaultedFunction('onSetup', function () { 26464 return noop; 26465 }) 26466 ]); 26467 var createSidebar = function (spec) { 26468 return asRaw('sidebar', sidebarSchema, spec); 26469 }; 26470 26471 var setup$6 = function (editor) { 26472 var sidebars = editor.ui.registry.getAll().sidebars; 26473 each(keys(sidebars), function (name) { 26474 var spec = sidebars[name]; 26475 var isActive = function () { 26476 return Optional.from(editor.queryCommandValue('ToggleSidebar')).is(name); 26477 }; 26478 editor.ui.registry.addToggleButton(name, { 26479 icon: spec.icon, 26480 tooltip: spec.tooltip, 26481 onAction: function (buttonApi) { 26482 editor.execCommand('ToggleSidebar', false, name); 26483 buttonApi.setActive(isActive()); 26484 }, 26485 onSetup: function (buttonApi) { 26486 var handleToggle = function () { 26487 return buttonApi.setActive(isActive()); 26488 }; 26489 editor.on('ToggleSidebar', handleToggle); 26490 return function () { 26491 editor.off('ToggleSidebar', handleToggle); 26492 }; 26493 } 26494 }); 26495 }); 26496 }; 26497 var getApi = function (comp) { 26498 return { 26499 element: function () { 26500 return comp.element.dom; 26501 } 26502 }; 26503 }; 26504 var makePanels = function (parts, panelConfigs) { 26505 var specs = map(keys(panelConfigs), function (name) { 26506 var spec = panelConfigs[name]; 26507 var bridged = getOrDie(createSidebar(spec)); 26508 return { 26509 name: name, 26510 getApi: getApi, 26511 onSetup: bridged.onSetup, 26512 onShow: bridged.onShow, 26513 onHide: bridged.onHide 26514 }; 26515 }); 26516 return map(specs, function (spec) { 26517 var editorOffCell = Cell(noop); 26518 return parts.slot(spec.name, { 26519 dom: { 26520 tag: 'div', 26521 classes: ['tox-sidebar__pane'] 26522 }, 26523 behaviours: SimpleBehaviours.unnamedEvents([ 26524 onControlAttached(spec, editorOffCell), 26525 onControlDetached(spec, editorOffCell), 26526 run(slotVisibility(), function (sidepanel, se) { 26527 var data = se.event; 26528 var optSidePanelSpec = find(specs, function (config) { 26529 return config.name === data.name; 26530 }); 26531 optSidePanelSpec.each(function (sidePanelSpec) { 26532 var handler = data.visible ? sidePanelSpec.onShow : sidePanelSpec.onHide; 26533 handler(sidePanelSpec.getApi(sidepanel)); 26534 }); 26535 }) 26536 ]) 26537 }); 26538 }); 26539 }; 26540 var makeSidebar = function (panelConfigs) { 26541 return SlotContainer.sketch(function (parts) { 26542 return { 26543 dom: { 26544 tag: 'div', 26545 classes: ['tox-sidebar__pane-container'] 26546 }, 26547 components: makePanels(parts, panelConfigs), 26548 slotBehaviours: SimpleBehaviours.unnamedEvents([runOnAttached(function (slotContainer) { 26549 return SlotContainer.hideAllSlots(slotContainer); 26550 })]) 26551 }; 26552 }); 26553 }; 26554 var setSidebar = function (sidebar, panelConfigs) { 26555 var optSlider = Composing.getCurrent(sidebar); 26556 optSlider.each(function (slider) { 26557 return Replacing.set(slider, [makeSidebar(panelConfigs)]); 26558 }); 26559 }; 26560 var toggleSidebar = function (sidebar, name) { 26561 var optSlider = Composing.getCurrent(sidebar); 26562 optSlider.each(function (slider) { 26563 var optSlotContainer = Composing.getCurrent(slider); 26564 optSlotContainer.each(function (slotContainer) { 26565 if (Sliding.hasGrown(slider)) { 26566 if (SlotContainer.isShowing(slotContainer, name)) { 26567 Sliding.shrink(slider); 26568 } else { 26569 SlotContainer.hideAllSlots(slotContainer); 26570 SlotContainer.showSlot(slotContainer, name); 26571 } 26572 } else { 26573 SlotContainer.hideAllSlots(slotContainer); 26574 SlotContainer.showSlot(slotContainer, name); 26575 Sliding.grow(slider); 26576 } 26577 }); 26578 }); 26579 }; 26580 var whichSidebar = function (sidebar) { 26581 var optSlider = Composing.getCurrent(sidebar); 26582 return optSlider.bind(function (slider) { 26583 var sidebarOpen = Sliding.isGrowing(slider) || Sliding.hasGrown(slider); 26584 if (sidebarOpen) {
26585 var optSlotContainer = Composing.getCurrent(slider); 26586 return optSlotContainer.bind(function (slotContainer) { 26587 return find(SlotContainer.getSlotNames(slotContainer), function (name) { 26588 return SlotContainer.isShowing(slotContainer, name); 26589 }); 26590 }); 26591 } else { 26592 return Optional.none(); 26593 } 26594 }); 26595 }; 26596 var fixSize = generate$1('FixSizeEvent'); 26597 var autoSize = generate$1('AutoSizeEvent'); 26598 var renderSidebar = function (spec) { 26599 return { 26600 uid: spec.uid, 26601 dom: { 26602 tag: 'div', 26603 classes: ['tox-sidebar'], 26604 attributes: { role: 'complementary' } 26605 }, 26606 components: [{ 26607 dom: { 26608 tag: 'div', 26609 classes: ['tox-sidebar__slider'] 26610 }, 26611 components: [], 26612 behaviours: derive$1([ 26613 Tabstopping.config({}), 26614 Focusing.config({}), 26615 Sliding.config({ 26616 dimension: { property: 'width' }, 26617 closedClass: 'tox-sidebar--sliding-closed', 26618 openClass: 'tox-sidebar--sliding-open', 26619 shrinkingClass: 'tox-sidebar--sliding-shrinking', 26620 growingClass: 'tox-sidebar--sliding-growing', 26621 onShrunk: function (slider) { 26622 var optSlotContainer = Composing.getCurrent(slider); 26623 optSlotContainer.each(SlotContainer.hideAllSlots); 26624 emit(slider, autoSize); 26625 }, 26626 onGrown: function (slider) { 26627 emit(slider, autoSize); 26628 }, 26629 onStartGrow: function (slider) { 26630 emitWith(slider, fixSize, { width: getRaw(slider.element, 'width').getOr('') }); 26631 }, 26632 onStartShrink: function (slider) { 26633 emitWith(slider, fixSize, { width: get$8(slider.element) + 'px' }); 26634 } 26635 }), 26636 Replacing.config({}), 26637 Composing.config({ 26638 find: function (comp) { 26639 var children = Replacing.contents(comp); 26640 return head(children); 26641 } 26642 }) 26643 ]) 26644 }], 26645 behaviours: derive$1([ 26646 ComposingConfigs.childAt(0), 26647 config('sidebar-sliding-events', [ 26648 run(fixSize, function (comp, se) { 26649 set$2(comp.element, 'width', se.event.width); 26650 }), 26651 run(autoSize, function (comp, _se) { 26652 remove$6(comp.element, 'width'); 26653 }) 26654 ]) 26655 ]) 26656 }; 26657 }; 26658 26659 var getAttrs = function (elem) { 26660 var attributes = elem.dom.attributes !== undefined ? elem.dom.attributes : []; 26661 return foldl(attributes, function (b, attr) { 26662 var _a; 26663 if (attr.name === 'class') { 26664 return b; 26665 } else { 26666 return __assign(__assign({}, b), (_a = {}, _a[attr.name] = attr.value, _a)); 26667 } 26668 }, {}); 26669 }; 26670 var getClasses = function (elem) { 26671 return Array.prototype.slice.call(elem.dom.classList, 0); 26672 }; 26673 var fromHtml$2 = function (html) { 26674 var elem = SugarElement.fromHtml(html); 26675 var children$1 = children(elem); 26676 var attrs = getAttrs(elem); 26677 var classes = getClasses(elem); 26678 var contents = children$1.length === 0 ? {} : { innerHtml: get$2(elem) }; 26679 return __assign({ 26680 tag: name(elem), 26681 classes: classes, 26682 attributes: attrs 26683 }, contents); 26684 }; 26685 26686 var renderSpinner = function (providerBackstage) { 26687 return { 26688 dom: { 26689 tag: 'div', 26690 attributes: { 'aria-label': providerBackstage.translate('Loading...') }, 26691 classes: ['tox-throbber__busy-spinner'] 26692 }, 26693 components: [{ dom: fromHtml$2('<div class="tox-spinner"><div></div><div></div><div></div></div>') }], 26694 behaviours: derive$1([ 26695 Keying.config({ 26696 mode: 'special', 26697 onTab: function () { 26698 return Optional.some(true); 26699 }, 26700 onShiftTab: function () { 26701 return Optional.some(true); 26702 } 26703 }), 26704 Focusing.config({}) 26705 ]) 26706 }; 26707 }; 26708 var toggleThrobber = function (comp, state, providerBackstage) { 26709 var element = comp.element; 26710 if (state === true) { 26711 Replacing.set(comp, [renderSpinner(providerBackstage)]); 26712 remove$6(element, 'display'); 26713 remove$1(element, 'aria-hidden'); 26714 } else { 26715 Replacing.set(comp, []); 26716 set$2(element, 'display', 'none'); 26717 set$1(element, 'aria-hidden', 'true'); 26718 } 26719 }; 26720 var renderThrobber = function (spec) { 26721 return { 26722 uid: spec.uid, 26723 dom: { 26724 tag: 'div', 26725 attributes: { 'aria-hidden': 'true' }, 26726 classes: ['tox-throbber'], 26727 styles: { display: 'none' } 26728 }, 26729 behaviours: derive$1([Replacing.config({})]), 26730 components: [] 26731 }; 26732 }; 26733 var setup$7 = function (editor, lazyThrobber, sharedBackstage) { 26734 var throbberState = Cell(false); 26735 var timer = Cell(Optional.none()); 26736 var toggle = function (state) { 26737 if (state !== throbberState.get()) { 26738 toggleThrobber(lazyThrobber(), state, sharedBackstage.providers); 26739 throbberState.set(state); 26740 editor.fire('AfterProgressState', { state: state }); 26741 } 26742 }; 26743 editor.on('ProgressState', function (e) { 26744 timer.get().each(global$2.clearTimeout); 26745 if (isNumber(e.time)) {
26746 var timerId = global$2.setEditorTimeout(editor, function () { 26747 return toggle(e.state); 26748 }, e.time); 26749 timer.set(Optional.some(timerId)); 26750 } else { 26751 toggle(e.state); 26752 timer.set(Optional.none()); 26753 } 26754 }); 26755 }; 26756 26757 var factory$h = function (detail, components, _spec) { 26758 var apis = { 26759 getSocket: function (comp) { 26760 return parts$d.getPart(comp, detail, 'socket'); 26761 }, 26762 setSidebar: function (comp, panelConfigs) { 26763 parts$d.getPart(comp, detail, 'sidebar').each(function (sidebar) { 26764 return setSidebar(sidebar, panelConfigs); 26765 }); 26766 }, 26767 toggleSidebar: function (comp, name) { 26768 parts$d.getPart(comp, detail, 'sidebar').each(function (sidebar) { 26769 return toggleSidebar(sidebar, name); 26770 }); 26771 }, 26772 whichSidebar: function (comp) { 26773 return parts$d.getPart(comp, detail, 'sidebar').bind(whichSidebar).getOrNull(); 26774 }, 26775 getHeader: function (comp) { 26776 return parts$d.getPart(comp, detail, 'header'); 26777 }, 26778 getToolbar: function (comp) { 26779 return parts$d.getPart(comp, detail, 'toolbar'); 26780 }, 26781 setToolbar: function (comp, groups) { 26782 parts$d.getPart(comp, detail, 'toolbar').each(function (toolbar) { 26783 toolbar.getApis().setGroups(toolbar, groups); 26784 }); 26785 }, 26786 setToolbars: function (comp, toolbars) { 26787 parts$d.getPart(comp, detail, 'multiple-toolbar').each(function (mToolbar) { 26788 CustomList.setItems(mToolbar, toolbars); 26789 }); 26790 }, 26791 refreshToolbar: function (comp) { 26792 var toolbar = parts$d.getPart(comp, detail, 'toolbar'); 26793 toolbar.each(function (toolbar) { 26794 return toolbar.getApis().refresh(toolbar); 26795 }); 26796 }, 26797 toggleToolbarDrawer: function (comp) { 26798 parts$d.getPart(comp, detail, 'toolbar').each(function (toolbar) { 26799 mapFrom(toolbar.getApis().toggle, function (toggle) { 26800 return toggle(toolbar); 26801 }); 26802 }); 26803 }, 26804 isToolbarDrawerToggled: function (comp) { 26805 return parts$d.getPart(comp, detail, 'toolbar').bind(function (toolbar) { 26806 return Optional.from(toolbar.getApis().isOpen).map(function (isOpen) { 26807 return isOpen(toolbar); 26808 }); 26809 }).getOr(false); 26810 }, 26811 getThrobber: function (comp) { 26812 return parts$d.getPart(comp, detail, 'throbber'); 26813 }, 26814 focusToolbar: function (comp) { 26815 var optToolbar = parts$d.getPart(comp, detail, 'toolbar').orThunk(function () { 26816 return parts$d.getPart(comp, detail, 'multiple-toolbar'); 26817 }); 26818 optToolbar.each(function (toolbar) { 26819 Keying.focusIn(toolbar); 26820 }); 26821 }, 26822 setMenubar: function (comp, menus) { 26823 parts$d.getPart(comp, detail, 'menubar').each(function (menubar) { 26824 SilverMenubar.setMenus(menubar, menus); 26825 }); 26826 }, 26827 focusMenubar: function (comp) { 26828 parts$d.getPart(comp, detail, 'menubar').each(function (menubar) { 26829 SilverMenubar.focus(menubar); 26830 }); 26831 } 26832 }; 26833 return { 26834 uid: detail.uid, 26835 dom: detail.dom, 26836 components: components, 26837 apis: apis, 26838 behaviours: detail.behaviours 26839 }; 26840 }; 26841 var partMenubar = partType$1.optional({ 26842 factory: SilverMenubar, 26843 name: 'menubar', 26844 schema: [strict$1('backstage')] 26845 }); 26846 var toolbarFactory = function (spec) { 26847 if (spec.type === ToolbarMode.sliding) { 26848 return renderSlidingMoreToolbar; 26849 } else if (spec.type === ToolbarMode.floating) { 26850 return renderFloatingMoreToolbar; 26851 } else { 26852 return renderToolbar; 26853 } 26854 }; 26855 var partMultipleToolbar = partType$1.optional({ 26856 factory: { 26857 sketch: function (spec) { 26858 return CustomList.sketch({ 26859 uid: spec.uid, 26860 dom: spec.dom, 26861 listBehaviours: derive$1([Keying.config({ 26862 mode: 'acyclic', 26863 selector: '.tox-toolbar' 26864 })]), 26865 makeItem: function () { 26866 return renderToolbar({ 26867 type: spec.type, 26868 uid: generate$1('multiple-toolbar-item'), 26869 cyclicKeying: false, 26870 initGroups: [], 26871 providers: spec.providers, 26872 onEscape: function () { 26873 spec.onEscape(); 26874 return Optional.some(true); 26875 } 26876 }); 26877 }, 26878 setupItem: function (_mToolbar, tc, data, _index) { 26879 Toolbar.setGroups(tc, data); 26880 }, 26881 shell: true 26882 }); 26883 } 26884 }, 26885 name: 'multiple-toolbar', 26886 schema: [
26887 strict$1('dom'), 26888 strict$1('onEscape') 26889 ] 26890 }); 26891 var partToolbar = partType$1.optional({ 26892 factory: { 26893 sketch: function (spec) { 26894 var renderer = toolbarFactory(spec); 26895 var toolbarSpec = { 26896 type: spec.type, 26897 uid: spec.uid, 26898 onEscape: function () { 26899 spec.onEscape(); 26900 return Optional.some(true); 26901 }, 26902 cyclicKeying: false, 26903 initGroups: [], 26904 getSink: spec.getSink, 26905 providers: spec.providers, 26906 moreDrawerData: { 26907 lazyToolbar: spec.lazyToolbar, 26908 lazyMoreButton: spec.lazyMoreButton, 26909 lazyHeader: spec.lazyHeader 26910 }, 26911 attributes: spec.attributes 26912 }; 26913 return renderer(toolbarSpec); 26914 } 26915 }, 26916 name: 'toolbar', 26917 schema: [ 26918 strict$1('dom'), 26919 strict$1('onEscape'), 26920 strict$1('getSink') 26921 ] 26922 }); 26923 var partHeader = partType$1.optional({ 26924 factory: { sketch: renderHeader }, 26925 name: 'header', 26926 schema: [strict$1('dom')] 26927 }); 26928 var partSocket = partType$1.optional({ 26929 name: 'socket', 26930 schema: [strict$1('dom')] 26931 }); 26932 var partSidebar = partType$1.optional({ 26933 factory: { sketch: renderSidebar }, 26934 name: 'sidebar', 26935 schema: [strict$1('dom')] 26936 }); 26937 var partThrobber = partType$1.optional({ 26938 factory: { sketch: renderThrobber }, 26939 name: 'throbber', 26940 schema: [strict$1('dom')] 26941 }); 26942 var OuterContainer = composite$1({ 26943 name: 'OuterContainer', 26944 factory: factory$h, 26945 configFields: [ 26946 strict$1('dom'), 26947 strict$1('behaviours') 26948 ], 26949 partFields: [ 26950 partHeader, 26951 partMenubar, 26952 partToolbar, 26953 partMultipleToolbar, 26954 partSocket, 26955 partSidebar, 26956 partThrobber 26957 ], 26958 apis: { 26959 getSocket: function (apis, comp) { 26960 return apis.getSocket(comp); 26961 }, 26962 setSidebar: function (apis, comp, panelConfigs) { 26963 apis.setSidebar(comp, panelConfigs); 26964 }, 26965 toggleSidebar: function (apis, comp, name) { 26966 apis.toggleSidebar(comp, name); 26967 }, 26968 whichSidebar: function (apis, comp) { 26969 return apis.whichSidebar(comp); 26970 }, 26971 getHeader: function (apis, comp) { 26972 return apis.getHeader(comp); 26973 }, 26974 getToolbar: function (apis, comp) { 26975 return apis.getToolbar(comp); 26976 }, 26977 setToolbar: function (apis, comp, grps) { 26978 var groups = map(grps, function (grp) { 26979 return renderToolbarGroup(grp); 26980 }); 26981 apis.setToolbar(comp, groups); 26982 }, 26983 setToolbars: function (apis, comp, ts) { 26984 var renderedToolbars = map(ts, function (g) { 26985 return map(g, renderToolbarGroup); 26986 }); 26987 apis.setToolbars(comp, renderedToolbars); 26988 }, 26989 refreshToolbar: function (apis, comp) { 26990 return apis.refreshToolbar(comp); 26991 }, 26992 toggleToolbarDrawer: function (apis, comp) { 26993 apis.toggleToolbarDrawer(comp); 26994 }, 26995 isToolbarDrawerToggled: function (apis, comp) { 26996 return apis.isToolbarDrawerToggled(comp); 26997 }, 26998 getThrobber: function (apis, comp) { 26999 return apis.getThrobber(comp); 27000 }, 27001 setMenubar: function (apis, comp, menus) { 27002 apis.setMenubar(comp, menus); 27003 }, 27004 focusMenubar: function (apis, comp) { 27005 apis.focusMenubar(comp); 27006 }, 27007 focusToolbar: function (apis, comp) { 27008 apis.focusToolbar(comp); 27009 } 27010 } 27011 }); 27012 27013 var defaultMenubar = 'file edit view insert format tools table help'; 27014 var defaultMenus = { 27015 file: { 27016 title: 'File', 27017 items: 'newdocument restoredraft | preview | export print | deleteallconversations' 27018 }, 27019 edit: { 27020 title: 'Edit', 27021 items: 'undo redo | cut copy paste pastetext | selectall | searchreplace' 27022 }, 27023 view: { 27024 title: 'View', 27025 items: 'code | visualaid visualchars visualblocks | spellchecker | preview fullscreen | showcomments' 27026 }, 27027 insert: { 27028 title: 'Insert', 27029 items: 'image link media addcomment pageembed template codesample inserttable | charmap emoticons hr | pagebreak nonbreaking anchor toc | insertdatetime' 27030 }, 27031 format: { 27032 title: 'Format', 27033 items: 'bold italic underline strikethrough superscript subscript codeformat | formats blockformats fontformats fontsizes align lineheight | forecolor backcolor | removeformat' 27034 }, 27035 tools: { 27036 title: 'Tools', 27037 items: 'spellchecker spellcheckerlanguage | a11ycheck code wordcount' 27038 }, 27039 table: { 27040 title: 'Table', 27041 items: 'inserttable | cell row column | advtablesort | tableprops deletetable' 27042 }, 27043 help: { 27044 title: 'Help', 27045 items: 'help' 27046 } 27047 }; 27048 var make$8 = function (menu, registry, editor) { 27049 var removedMenuItems = getRemovedMenuItems(editor).split(/[ ,]/); 27050 return { 27051 text: menu.title, 27052 getItems: function () { 27053 return bind(menu.items, function (i) { 27054 var itemName = i.toLowerCase(); 27055 if (itemName.trim().length === 0) { 27056 return []; 27057 } else if (exists(removedMenuItems, function (removedMenuItem) { 27058 return removedMenuItem === itemName; 27059 })) { 27060 return []; 27061 } else if (itemName === 'separator' || itemName === '|') { 27062 return [{ type: 'separator' }]; 27063 } else if (registry.menuItems[itemName]) { 27064 return [registry.menuItems[itemName]]; 27065 } else { 27066 return []; 27067 } 27068 }); 27069 } 27070 }; 27071 }; 27072 var parseItemsString = function (items) { 27073 if (typeof items === 'string') { 27074 return items.split(' '); 27075 } 27076 return items; 27077 }; 27078 var identifyMenus = function (editor, registry) { 27079 var rawMenuData = __assign(__assign({}, defaultMenus), registry.menus); 27080 var userDefinedMenus = keys(registry.menus).length > 0; 27081 var menubar = registry.menubar === undefined || registry.menubar === true ? parseItemsString(defaultMenubar) : parseItemsString(registry.menubar === false ? '' : registry.menubar);
27082 var validMenus = filter(menubar, function (menuName) { 27083 return userDefinedMenus ? registry.menus.hasOwnProperty(menuName) && registry.menus[menuName].hasOwnProperty('items') || defaultMenus.hasOwnProperty(menuName) : defaultMenus.hasOwnProperty(menuName); 27084 }); 27085 var menus = map(validMenus, function (menuName) { 27086 var menuData = rawMenuData[menuName]; 27087 return make$8({ 27088 title: menuData.title, 27089 items: parseItemsString(menuData.items) 27090 }, registry, editor); 27091 }); 27092 return filter(menus, function (menu) { 27093 var isNotSeparator = function (item) { 27094 return item.type !== 'separator'; 27095 }; 27096 return menu.getItems().length > 0 && exists(menu.getItems(), isNotSeparator); 27097 }); 27098 }; 27099 27100 var fireSkinLoaded$1 = function (editor) { 27101 var done = function () { 27102 editor._skinLoaded = true; 27103 fireSkinLoaded(editor); 27104 }; 27105 return function () { 27106 if (editor.initialized) { 27107 done(); 27108 } else { 27109 editor.on('init', done); 27110 } 27111 }; 27112 }; 27113 var fireSkinLoadError$1 = function (editor, err) { 27114 return function () { 27115 return fireSkinLoadError(editor, { message: err }); 27116 }; 27117 }; 27118 27119 var loadStylesheet = function (editor, stylesheetUrl, styleSheetLoader) { 27120 return new global$4(function (resolve, reject) { 27121 styleSheetLoader.load(stylesheetUrl, resolve, reject); 27122 editor.on('remove', function () { 27123 return styleSheetLoader.unload(stylesheetUrl); 27124 }); 27125 }); 27126 }; 27127 var loadUiSkins = function (editor, skinUrl) { 27128 var skinUiCss = skinUrl + '/skin.min.css'; 27129 return loadStylesheet(editor, skinUiCss, editor.ui.styleSheetLoader); 27130 }; 27131 var loadShadowDomUiSkins = function (editor, skinUrl) { 27132 var isInShadowRoot$1 = isInShadowRoot(SugarElement.fromDom(editor.getElement())); 27133 if (isInShadowRoot$1) { 27134 var shadowDomSkinCss = skinUrl + '/skin.shadowdom.min.css'; 27135 return loadStylesheet(editor, shadowDomSkinCss, global$5.DOM.styleSheetLoader); 27136 } else { 27137 return global$4.resolve(); 27138 } 27139 }; 27140 var loadSkin = function (isInline, editor) { 27141 var skinUrl = getSkinUrl(editor); 27142 if (skinUrl) { 27143 editor.contentCSS.push(skinUrl + (isInline ? '/content.inline' : '/content') + '.min.css'); 27144 } 27145 if (isSkinDisabled(editor) === false && isString(skinUrl)) { 27146 global$4.all([ 27147 loadUiSkins(editor, skinUrl), 27148 loadShadowDomUiSkins(editor, skinUrl) 27149 ]).then(fireSkinLoaded$1(editor), fireSkinLoadError$1(editor, 'Skin could not be loaded')); 27150 } else { 27151 fireSkinLoaded$1(editor)(); 27152 } 27153 }; 27154 var iframe = curry(loadSkin, false); 27155 var inline = curry(loadSkin, true); 27156 27157 var setToolbar = function (editor, uiComponents, rawUiConfig, backstage) { 27158 var comp = uiComponents.outerContainer; 27159 var toolbarConfig = rawUiConfig.toolbar; 27160 var toolbarButtonsConfig = rawUiConfig.buttons; 27161 if (isArrayOf(toolbarConfig, isString)) { 27162 var toolbars = toolbarConfig.map(function (t) { 27163 var config = { 27164 toolbar: t, 27165 buttons: toolbarButtonsConfig, 27166 allowToolbarGroups: rawUiConfig.allowToolbarGroups 27167 }; 27168 return identifyButtons(editor, config, { backstage: backstage }, Optional.none()); 27169 }); 27170 OuterContainer.setToolbars(comp, toolbars); 27171 } else { 27172 OuterContainer.setToolbar(comp, identifyButtons(editor, rawUiConfig, { backstage: backstage }, Optional.none())); 27173 } 27174 }; 27175 27176 var detection = detect$3(); 27177 var isiOS12 = detection.os.isiOS() && detection.os.version.major <= 12; 27178 var setupEvents = function (editor, uiComponents) { 27179 var dom = editor.dom; 27180 var contentWindow = editor.getWin(); 27181 var initialDocEle = editor.getDoc().documentElement; 27182 var lastWindowDimensions = Cell(SugarPosition(contentWindow.innerWidth, contentWindow.innerHeight)); 27183 var lastDocumentDimensions = Cell(SugarPosition(initialDocEle.offsetWidth, initialDocEle.offsetHeight)); 27184 var resizeWindow = function () { 27185 var outer = lastWindowDimensions.get(); 27186 if (outer.left !== contentWindow.innerWidth || outer.top !== contentWindow.innerHeight) { 27187 lastWindowDimensions.set(SugarPosition(contentWindow.innerWidth, contentWindow.innerHeight)); 27188 fireResizeContent(editor); 27189 } 27190 }; 27191 var resizeDocument = function () { 27192 var docEle = editor.getDoc().documentElement; 27193 var inner = lastDocumentDimensions.get(); 27194 if (inner.left !== docEle.offsetWidth || inner.top !== docEle.offsetHeight) { 27195 lastDocumentDimensions.set(SugarPosition(docEle.offsetWidth, docEle.offsetHeight)); 27196 fireResizeContent(editor); 27197 } 27198 }; 27199 var scroll = function (e) { 27200 return fireScrollContent(editor, e); 27201 }; 27202 dom.bind(contentWindow, 'resize', resizeWindow); 27203 dom.bind(contentWindow, 'scroll', scroll); 27204 var elementLoad = capture$1(SugarElement.fromDom(editor.getBody()), 'load', resizeDocument); 27205 var mothership = uiComponents.uiMothership.element; 27206 editor.on('hide', function () { 27207 set$2(mothership, 'display', 'none'); 27208 }); 27209 editor.on('show', function () { 27210 remove$6(mothership, 'display'); 27211 }); 27212 editor.on('NodeChange', resizeDocument); 27213 editor.on('remove', function () { 27214 elementLoad.unbind(); 27215 dom.unbind(contentWindow, 'resize', resizeWindow); 27216 dom.unbind(contentWindow, 'scroll', scroll); 27217 contentWindow = null; 27218 }); 27219 }; 27220 var render$1 = function (editor, uiComponents, rawUiConfig, backstage, args
27220) { 27221 var lastToolbarWidth = Cell(0); 27222 var outerContainer = uiComponents.outerContainer; 27223 iframe(editor); 27224 var eTargetNode = SugarElement.fromDom(args.targetNode); 27225 var uiRoot = getContentContainer(getRootNode(eTargetNode)); 27226 attachSystemAfter(eTargetNode, uiComponents.mothership); 27227 attachSystem(uiRoot, uiComponents.uiMothership); 27228 editor.on('PostRender', function () { 27229 setToolbar(editor, uiComponents, rawUiConfig, backstage); 27230 lastToolbarWidth.set(editor.getWin().innerWidth); 27231 OuterContainer.setMenubar(outerContainer, identifyMenus(editor, rawUiConfig)); 27232 OuterContainer.setSidebar(outerContainer, rawUiConfig.sidebar); 27233 setupEvents(editor, uiComponents); 27234 }); 27235 var socket = OuterContainer.getSocket(outerContainer).getOrDie('Could not find expected socket element'); 27236 if (isiOS12) { 27237 setAll$1(socket.element, { 27238 'overflow': 'scroll', 27239 '-webkit-overflow-scrolling': 'touch' 27240 }); 27241 var limit = first(function () { 27242 editor.fire('ScrollContent'); 27243 }, 20); 27244 var unbinder = bind$3(socket.element, 'scroll', limit.throttle); 27245 editor.on('remove', unbinder.unbind); 27246 } 27247 setupReadonlyModeSwitch(editor, uiComponents); 27248 editor.addCommand('ToggleSidebar', function (_ui, value) { 27249 OuterContainer.toggleSidebar(outerContainer, value); 27250 editor.fire('ToggleSidebar'); 27251 }); 27252 editor.addQueryValueHandler('ToggleSidebar', function () { 27253 return OuterContainer.whichSidebar(outerContainer); 27254 }); 27255 var toolbarMode = getToolbarMode(editor); 27256 var refreshDrawer = function () { 27257 OuterContainer.refreshToolbar(uiComponents.outerContainer); 27258 }; 27259 if (toolbarMode === ToolbarMode.sliding || toolbarMode === ToolbarMode.floating) { 27260 editor.on('ResizeWindow ResizeEditor ResizeContent', function () { 27261 var width = editor.getWin().innerWidth; 27262 if (width !== lastToolbarWidth.get()) { 27263 refreshDrawer(); 27264 lastToolbarWidth.set(width); 27265 } 27266 }); 27267 } 27268 var api = { 27269 enable: function () { 27270 broadcastReadonly(uiComponents, false); 27271 }, 27272 disable: function () { 27273 broadcastReadonly(uiComponents, true); 27274 }, 27275 isDisabled: function () { 27276 return Disabling.isDisabled(outerContainer); 27277 } 27278 }; 27279 return { 27280 iframeContainer: socket.element.dom, 27281 editorContainer: outerContainer.element.dom, 27282 api: api 27283 }; 27284 }; 27285 27286 var Iframe = /*#__PURE__*/Object.freeze({ 27287 __proto__: null, 27288 render: render$1 27289 }); 27290 27291 var parseToInt = function (val) { 27292 var re = /^[0-9\.]+(|px)$/i; 27293 if (re.test('' + val)) { 27294 return Optional.some(parseInt('' + val, 10)); 27295 } 27296 return Optional.none(); 27297 }; 27298 var numToPx = function (val) { 27299 return isNumber(val) ? val + 'px' : val; 27300 }; 27301 var calcCappedSize = function (size, minSize, maxSize) { 27302 var minOverride = minSize.filter(function (min) { 27303 return size < min; 27304 }); 27305 var maxOverride = maxSize.filter(function (max) { 27306 return size > max; 27307 }); 27308 return minOverride.or(maxOverride).getOr(size); 27309 }; 27310 27311 var getHeight$1 = function (editor) { 27312 var baseHeight = getHeightSetting(editor); 27313 var minHeight = getMinHeightSetting(editor); 27314 var maxHeight = getMaxHeightSetting(editor); 27315 return parseToInt(baseHeight).map(function (height) { 27316 return calcCappedSize(height, minHeight, maxHeight); 27317 }); 27318 }; 27319 var getHeightWithFallback = function (editor) { 27320 var height = getHeight$1(editor); 27321 return height.getOr(getHeightSetting(editor)); 27322 }; 27323 var getWidth$1 = function (editor) { 27324 var baseWidth = getWidthSetting(editor); 27325 var minWidth = getMinWidthSetting(editor); 27326 var maxWidth = getMaxWidthSetting(editor); 27327 return parseToInt(baseWidth).map(function (width) { 27328 return calcCappedSize(width, minWidth, maxWidth); 27329 }); 27330 }; 27331 var getWidthWithFallback = function (editor) { 27332 var width = getWidth$1(editor); 27333 return width.getOr(getWidthSetting(editor)); 27334 }; 27335 27336 var InlineHeader = function (editor, targetElm, uiComponents, backstage, floatContainer) { 27337 var uiMothership = uiComponents.uiMothership, outerContainer = uiComponents.outerContainer; 27338 var DOM = global$5.DOM; 27339 var useFixedToolbarContainer = useFixedContainer(editor); 27340 var isSticky = isStickyToolbar(editor); 27341 var editorMaxWidthOpt = getMaxWidthSetting(editor).or(getWidth$1(editor)); 27342 var headerBackstage = backstage.shared.header; 27343 var isPositionedAtTop = headerBackstage.isPositionedAtTop; 27344 var toolbarMode = getToolbarMode(editor); 27345 var isSplitToolbar = toolbarMode === ToolbarMode.sliding || toolbarMode === ToolbarMode.floating; 27346 var visible = Cell(false); 27347 var isVisible = function () { 27348 return visible.get() && !editor.removed; 27349 }; 27350 var calcToolbarOffset = function (toolbar) { 27351 return isSplitToolbar ? toolbar.fold(function () { 27352 return 0; 27353 }, function (tbar) { 27354 return tbar.components().length > 1 ? get$7(tbar.components()[1].element) : 0; 27355 }) : 0; 27356 }; 27357 var calcMode = function (container) { 27358 switch (getToolbarLocation(editor)) { 27359 case ToolbarLocation.auto: 27360 var toolbar_1 = OuterContainer.getToolbar(outerContainer); 27361 var offset = calcToolbarOffset(toolbar_1); 27362 var toolbarHeight = get$7(container.element) - offset; 27363 var targetBounds = box(targetElm); 27364 var roomAtTop = targetBounds.y > toolbarHeight; 27365 if (roomAtTop) { 27366 return 'top'; 27367 } else { 27368 var doc = documentElement(targetElm); 27369 var docHeight = Math.max(doc.dom.scrollHeight, get$7(doc));
27370 var roomAtBottom = targetBounds.bottom < docHeight - toolbarHeight; 27371 if (roomAtBottom) { 27372 return 'bottom'; 27373 } else { 27374 var winBounds = win(); 27375 var isRoomAtBottomViewport = winBounds.bottom < targetBounds.bottom - toolbarHeight; 27376 return isRoomAtBottomViewport ? 'bottom' : 'top'; 27377 } 27378 } 27379 case ToolbarLocation.bottom: 27380 return 'bottom'; 27381 case ToolbarLocation.top: 27382 default: 27383 return 'top'; 27384 } 27385 }; 27386 var setupMode = function (mode) { 27387 var container = floatContainer.get(); 27388 Docking.setModes(container, [mode]); 27389 headerBackstage.setDockingMode(mode); 27390 var verticalDir = isPositionedAtTop() ? AttributeValue.TopToBottom : AttributeValue.BottomToTop; 27391 set$1(container.element, Attribute, verticalDir); 27392 }; 27393 var updateChromeWidth = function () { 27394 var maxWidth = editorMaxWidthOpt.getOrThunk(function () { 27395 var bodyMargin = parseToInt(get$5(body(), 'margin-left')).getOr(0); 27396 return get$8(body()) - absolute(targetElm).left + bodyMargin; 27397 }); 27398 set$2(floatContainer.get().element, 'max-width', maxWidth + 'px'); 27399 }; 27400 var updateChromePosition = function () { 27401 var toolbar = OuterContainer.getToolbar(outerContainer); 27402 var offset = calcToolbarOffset(toolbar); 27403 var targetBounds = box(targetElm); 27404 var top = isPositionedAtTop() ? Math.max(targetBounds.y - get$7(floatContainer.get().element) + offset, 0) : targetBounds.bottom; 27405 setAll$1(outerContainer.element, { 27406 position: 'absolute', 27407 top: Math.round(top) + 'px', 27408 left: Math.round(targetBounds.x) + 'px' 27409 }); 27410 }; 27411 var repositionPopups$1 = function () { 27412 uiMothership.broadcastOn([repositionPopups()], {}); 27413 }; 27414 var updateChromeUi = function (resetDocking) { 27415 if (resetDocking === void 0) { 27416 resetDocking = false; 27417 } 27418 if (!isVisible()) { 27419 return; 27420 } 27421 if (!useFixedToolbarContainer) { 27422 updateChromeWidth(); 27423 } 27424 if (isSplitToolbar) { 27425 OuterContainer.refreshToolbar(outerContainer); 27426 } 27427 if (!useFixedToolbarContainer) { 27428 updateChromePosition(); 27429 } 27430 if (isSticky) { 27431 var floatContainerComp = floatContainer.get(); 27432 resetDocking ? Docking.reset(floatContainerComp) : Docking.refresh(floatContainerComp); 27433 } 27434 repositionPopups$1(); 27435 }; 27436 var updateMode = function (updateUi) { 27437 if (updateUi === void 0) { 27438 updateUi = true; 27439 } 27440 if (useFixedToolbarContainer || !isSticky || !isVisible()) { 27441 return; 27442 } 27443 var currentMode = headerBackstage.getDockingMode(); 27444 var newMode = calcMode(floatContainer.get()); 27445 if (newMode !== currentMode) { 27446 setupMode(newMode); 27447 if (updateUi) { 27448 updateChromeUi(true); 27449 } 27450 } 27451 }; 27452 var show = function () { 27453 visible.set(true); 27454 set$2(outerContainer.element, 'display', 'flex'); 27455 DOM.addClass(editor.getBody(), 'mce-edit-focus'); 27456 remove$6(uiMothership.element, 'display'); 27457 updateMode(false); 27458 updateChromeUi(); 27459 }; 27460 var hide = function () { 27461 visible.set(false); 27462 if (uiComponents.outerContainer) { 27463 set$2(outerContainer.element, 'display', 'none'); 27464 DOM.removeClass(editor.getBody(), 'mce-edit-focus'); 27465 } 27466 set$2(uiMothership.element, 'display', 'none'); 27467 }; 27468 return { 27469 isVisible: isVisible, 27470 isPositionedAtTop: isPositionedAtTop, 27471 show: show, 27472 hide: hide, 27473 update: updateChromeUi, 27474 updateMode: updateMode, 27475 repositionPopups: repositionPopups$1 27476 }; 27477 }; 27478 27479 var getTargetPosAndBounds = function (targetElm, isToolbarTop) { 27480 var bounds = box(targetElm); 27481 return { 27482 pos: isToolbarTop ? bounds.y : bounds.bottom,
27483 bounds: bounds 27484 }; 27485 }; 27486 var setupEvents$1 = function (editor, targetElm, ui, toolbarPersist) { 27487 var prevPosAndBounds = Cell(getTargetPosAndBounds(targetElm, ui.isPositionedAtTop())); 27488 var resizeContent = function (e) { 27489 var _a = getTargetPosAndBounds(targetElm, ui.isPositionedAtTop()), pos = _a.pos, bounds = _a.bounds; 27490 var _b = prevPosAndBounds.get(), prevPos = _b.pos, prevBounds = _b.bounds; 27491 var hasResized = bounds.height !== prevBounds.height || bounds.width !== prevBounds.width; 27492 prevPosAndBounds.set({ 27493 pos: pos, 27494 bounds: bounds 27495 }); 27496 if (hasResized) { 27497 fireResizeContent(editor, e); 27498 } 27499 if (ui.isVisible()) { 27500 if (prevPos !== pos) { 27501 ui.update(true); 27502 } else if (hasResized) { 27503 ui.updateMode(); 27504 ui.repositionPopups(); 27505 } 27506 } 27507 }; 27508 if (!toolbarPersist) { 27509 editor.on('activate', ui.show); 27510 editor.on('deactivate', ui.hide); 27511 } 27512 editor.on('SkinLoaded ResizeWindow', function () { 27513 return ui.update(true); 27514 }); 27515 editor.on('NodeChange keydown', function (e) { 27516 global$2.requestAnimationFrame(function () { 27517 return resizeContent(e); 27518 }); 27519 }); 27520 editor.on('ScrollWindow', function () { 27521 return ui.updateMode(); 27522 }); 27523 var elementLoad = unbindable(); 27524 elementLoad.set(capture$1(SugarElement.fromDom(editor.getBody()), 'load', resizeContent)); 27525 editor.on('remove', function () { 27526 elementLoad.clear(); 27527 }); 27528 }; 27529 var render$2 = function (editor, uiComponents, rawUiConfig, backstage, args) { 27530 var mothership = uiComponents.mothership, uiMothership = uiComponents.uiMothership, outerContainer = uiComponents.outerContainer; 27531 var floatContainer = Cell(null); 27532 var targetElm = SugarElement.fromDom(args.targetNode); 27533 var ui = InlineHeader(editor, targetElm, uiComponents, backstage, floatContainer); 27534 var toolbarPersist = isToolbarPersist(editor); 27535 inline(editor); 27536 var render = function () { 27537 if (floatContainer.get()) { 27538 ui.show(); 27539 return; 27540 } 27541 floatContainer.set(OuterContainer.getHeader(outerContainer).getOrDie()); 27542 var uiContainer = getUiContainer(editor); 27543 attachSystem(uiContainer, mothership); 27544 attachSystem(uiContainer, uiMothership); 27545 setToolbar(editor, uiComponents, rawUiConfig, backstage); 27546 OuterContainer.setMenubar(outerContainer, identifyMenus(editor, rawUiConfig)); 27547 ui.show(); 27548 setupEvents$1(editor, targetElm, ui, toolbarPersist); 27549 editor.nodeChanged(); 27550 }; 27551 editor.on('show', render); 27552 editor.on('hide', ui.hide); 27553 if (!toolbarPersist) { 27554 editor.on('focus', render); 27555 editor.on('blur', ui.hide); 27556 } 27557 editor.on('init', function () { 27558 if (editor.hasFocus() || toolbarPersist) { 27559 render(); 27560 } 27561 }); 27562 setupReadonlyModeSwitch(editor, uiComponents); 27563 var api = { 27564 show: function () { 27565 ui.show(); 27566 }, 27567 hide: function () { 27568 ui.hide(); 27569 }, 27570 enable: function () { 27571 broadcastReadonly(uiComponents, false); 27572 }, 27573 disable: function () { 27574 broadcastReadonly(uiComponents, true); 27575 }, 27576 isDisabled: function () { 27577 return Disabling.isDisabled(outerContainer); 27578 } 27579 }; 27580 return { 27581 editorContainer: outerContainer.element.dom, 27582 api: api 27583 }; 27584 }; 27585 27586 var Inline = /*#__PURE__*/Object.freeze({ 27587 __proto__: null, 27588 render: render$2 27589 }); 27590 27591 var register$5 = function (editor) { 27592 var alignToolbarButtons = [ 27593 { 27594 name: 'alignleft', 27595 text: 'Align left', 27596 cmd: 'JustifyLeft', 27597 icon: 'align-left' 27598 }, 27599 { 27600 name: 'aligncenter', 27601 text: 'Align center', 27602 cmd: 'JustifyCenter', 27603 icon: 'align-center' 27604 }, 27605 { 27606 name: 'alignright', 27607 text: 'Align right', 27608 cmd: 'JustifyRight', 27609 icon: 'align-right' 27610 }, 27611 { 27612 name: 'alignjustify', 27613 text: 'Justify', 27614 cmd: 'JustifyFull', 27615 icon: 'align-justify' 27616 } 27617 ]; 27618 global$c.each(alignToolbarButtons, function (item) { 27619 editor.ui.registry.addToggleButton(item.name, { 27620 tooltip: item.text, 27621 onAction: function () { 27622 return editor.execCommand(item.cmd); 27623 }, 27624 icon: item.icon, 27625 onSetup: onSetupFormatToggle(editor, item.name) 27626 }); 27627 }); 27628 var alignNoneToolbarButton = { 27629 name: 'alignnone', 27630 text: 'No alignment', 27631 cmd: 'JustifyNone', 27632 icon: 'align-none' 27633 }; 27634 editor.ui.registry.addButton(alignNoneToolbarButton.name, { 27635 tooltip: alignNoneToolbarButton.text, 27636 onAction: function () { 27637 return editor.execCommand(alignNoneToolbarButton.cmd); 27638 }, 27639 icon: alignNoneToolbarButton.icon 27640 }); 27641 }; 27642 27643 var register$6 = function (editor, backstage) { 27644 alignSelectMenu(editor, backstage); 27645 fontSelectMenu(editor, backstage); 27646 styleSelectMenu(editor, backstage); 27647 formatSelectMenu(editor, backstage); 27648 fontsizeSelectMenu(editor, backstage); 27649 }; 27650 27651 var toggleOutdentState = function (api, editor) { 27652 api.setDisabled(!editor.queryCommandState('outdent')); 27653 var onNodeChange = function () { 27654 api.setDisabled(!editor.queryCommandState('outdent')); 27655 }; 27656 editor.on('NodeChange', onNodeChange); 27657 return function () { 27658 return editor.off('NodeChange', onNodeChange); 27659 }; 27660 }; 27661 var registerButtons = function (editor) {
27662 editor.ui.registry.addButton('outdent', { 27663 tooltip: 'Decrease indent', 27664 icon: 'outdent', 27665 onSetup: function (api) { 27666 return toggleOutdentState(api, editor); 27667 }, 27668 onAction: function () { 27669 return editor.execCommand('outdent'); 27670 } 27671 }); 27672 editor.ui.registry.addButton('indent', { 27673 tooltip: 'Increase indent', 27674 icon: 'indent', 27675 onAction: function () { 27676 return editor.execCommand('indent'); 27677 } 27678 }); 27679 }; 27680 var register$7 = function (editor) { 27681 registerButtons(editor); 27682 }; 27683 27684 var units = { 27685 unsupportedLength: [ 27686 'em', 27687 'ex', 27688 'cap', 27689 'ch', 27690 'ic', 27691 'rem', 27692 'lh', 27693 'rlh', 27694 'vw', 27695 'vh', 27696 'vi', 27697 'vb', 27698 'vmin', 27699 'vmax', 27700 'cm', 27701 'mm', 27702 'Q', 27703 'in', 27704 'pc', 27705 'pt', 27706 'px' 27707 ], 27708 fixed: [ 27709 'px', 27710 'pt' 27711 ], 27712 relative: ['%'], 27713 empty: [''] 27714 }; 27715 var pattern = function () { 27716 var decimalDigits = '[0-9]+'; 27717 var signedInteger = '[+-]?' + decimalDigits; 27718 var exponentPart = '[eE]' + signedInteger; 27719 var dot = '\\.'; 27720 var opt = function (input) { 27721 return '(?:' + input + ')?'; 27722 }; 27723 var unsignedDecimalLiteral = [ 27724 'Infinity', 27725 decimalDigits + dot + opt(decimalDigits) + opt(exponentPart), 27726 dot + decimalDigits + opt(exponentPart), 27727 decimalDigits + opt(exponentPart) 27728 ].join('|'); 27729 var float = '[+-]?(?:' + unsignedDecimalLiteral + ')'; 27730 return new RegExp('^(' + float + ')(.*)$'); 27731 }(); 27732 var isUnit = function (unit, accepted) { 27733 return exists(accepted, function (acc) { 27734 return exists(units[acc], function (check) { 27735 return unit === check; 27736 }); 27737 }); 27738 }; 27739 var parse = function (input, accepted) { 27740 var match = Optional.from(pattern.exec(input)); 27741 return match.bind(function (array) { 27742 var value = Number(array[1]); 27743 var unitRaw = array[2]; 27744 if (isUnit(unitRaw, accepted)) { 27745 return Optional.some({ 27746 value: value, 27747 unit: unitRaw 27748 }); 27749 } else { 27750 return Optional.none(); 27751 } 27752 }); 27753 }; 27754 var normalise = function (input, accepted) { 27755 return parse(input, accepted).map(function (_a) { 27756 var value = _a.value, unit = _a.unit; 27757 return value + unit; 27758 }); 27759 }; 27760 27761 var normaliseLineHeight = function (input) { 27762 return normalise(input, [ 27763 'fixed', 27764 'relative', 27765 'empty' 27766 ]).getOr(input); 27767 }; 27768 var getLineHeights = function (editor) { 27769 var options = getLineHeightFormats(editor); 27770 var apis = new Map(); 27771 var lastApi = destroyable(); 27772 var callback = function () { 27773 var current = normaliseLineHeight(editor.queryCommandValue('LineHeight')); 27774 Optional.from(apis.get(current)).fold(function () { 27775 return lastApi.clear(); 27776 }, function (api) { 27777 lastApi.set({ 27778 destroy: function () { 27779 api.setActive(false); 27780 } 27781 }); 27782 api.setActive(true); 27783 }); 27784 }; 27785 editor.on('nodeChange', callback); 27786 return map(options, function (value, i) { 27787 return { 27788 type: 'togglemenuitem', 27789 text: value, 27790 onSetup: function (api) { 27791 apis.set(normaliseLineHeight(value), api); 27792 if (i + 1 === options.length) { 27793 callback(); 27794 } 27795 return function () { 27796 if (i === 0) { 27797 editor.off('nodeChange', callback); 27798 lastApi.clear(); 27799 } 27800 }; 27801 }, 27802 onAction: function () { 27803 return editor.execCommand('LineHeight', false, value); 27804 } 27805 }; 27806 }); 27807 }; 27808 var registerMenuItems = function (editor) { 27809 editor.ui.registry.addNestedMenuItem('lineheight', { 27810 type: 'nestedmenuitem', 27811 text: 'Line height', 27812 getSubmenuItems: function () { 27813 return getLineHeights(editor); 27814 } 27815 }); 27816 }; 27817 var registerButtons$1 = function (editor) { 27818 editor.ui.registry.addMenuButton('lineheight', { 27819 tooltip: 'Line height', 27820 icon: 'line-height', 27821 fetch: function (callback) { 27822 return callback(getLineHeights(editor)); 27823 } 27824 }); 27825 }; 27826 var register$8 = function (editor) { 27827 registerMenuItems(editor); 27828 registerButtons$1(editor); 27829 }; 27830 27831 var toggleFormat = function (editor, fmt) { 27832 return function () { 27833 editor.execCommand('mceToggleFormat', false, fmt); 27834 }; 27835 }; 27836 var registerFormatButtons = function (editor) { 27837 global$c.each([ 27838 { 27839 name: 'bold', 27840 text: 'Bold', 27841 icon: 'bold' 27842 }, 27843 { 27844 name: 'italic', 27845 text: 'Italic', 27846 icon: 'italic' 27847 }, 27848 { 27849 name: 'underline', 27850 text: 'Underline', 27851 icon: 'underline' 27852 }, 27853 { 27854 name: 'strikethrough', 27855 text: 'Strikethrough', 27856 icon: 'strike-through' 27857 }, 27858 { 27859 name: 'subscript', 27860 text: 'Subscript', 27861 icon: 'subscript' 27862 }, 27863 { 27864 name: 'superscript', 27865 text: 'Superscript', 27866 icon: 'superscript' 27867 } 27868 ], function (btn, _idx) { 27869 editor.ui.registry.addToggleButton(btn.name, { 27870 tooltip: btn.text, 27871 icon: btn.icon, 27872 onSetup: onSetupFormatToggle(editor, btn.name), 27873 onAction: toggleFormat(editor, btn.name) 27874 }); 27875 }); 27876 for (var i = 1; i <= 6; i++) { 27877 var name_1 = 'h' + i; 27878 editor.ui.registry.addToggleButton(name_1, { 27879 text: name_1.toUpperCase(), 27880 tooltip: 'Heading ' + i, 27881 onSetup: onSetupFormatToggle(editor, name_1), 27882 onAction: toggleFormat(editor, name_1) 27883 }); 27884 } 27885 }; 27886 var registerCommandButtons = function (editor) { 27887 global$c.each([ 27888 { 27889 name: 'cut', 27890 text: 'Cut', 27891 action: 'Cut', 27892 icon: 'cut' 27893 }, 27894 { 27895 name: 'copy', 27896 text: 'Copy', 27897 action: 'Copy', 27898 icon: 'copy' 27899 }, 27900 { 27901 name: 'paste', 27902 text: 'Paste', 27903 action: 'Paste', 27904 icon: 'paste' 27905 }, 27906 { 27907 name: 'help', 27908 text: 'Help', 27909 action: 'mceHelp', 27910 icon: 'help' 27911 }, 27912 { 27913 name: 'selectall', 27914 text: 'Select all', 27915 action: 'SelectAll', 27916 icon: 'select-all' 27917 }, 27918 { 27919 name: 'newdocument', 27920 text: 'New document', 27921 action: 'mceNewDocument', 27922 icon: 'new-document' 27923 }, 27924 { 27925 name: 'removeformat', 27926 text: 'Clear formatting', 27927 action: 'RemoveFormat', 27928 icon: 'remove-formatting' 27929 }, 27930 { 27931 name: 'remove', 27932 text: 'Remove', 27933 action: 'Delete', 27934 icon: 'remove' 27935 } 27936 ], function (btn) { 27937 editor.ui.registry.addButton(btn.name, { 27938 tooltip: btn.text, 27939 icon: btn.icon, 27940 onAction: function () { 27941 return editor.execCommand(btn.action); 27942 } 27943 }); 27944 }); 27945 }; 27946 var registerCommandToggleButtons = function (editor) { 27947 global$c.each([{ 27948 name: 'blockquote', 27949 text: 'Blockquote', 27950 action: 'mceBlockQuote', 27951 icon: 'quote' 27952 }], function (btn) { 27953 editor.ui.registry.addToggleButton(btn.name, { 27954 tooltip: btn.text, 27955 icon: btn.icon, 27956 onAction: function () { 27957 return editor.execCommand(btn.action); 27958 }, 27959 onSetup: onSetupFormatToggle(editor, btn.name) 27960 }); 27961 }); 27962 }; 27963 var registerButtons$2 = function (editor) { 27964 registerFormatButtons(editor); 27965 registerCommandButtons(editor); 27966 registerCommandToggleButtons(editor); 27967 }; 27968 var registerMenuItems$1 = function (editor) { 27969 global$c.each([ 27970 { 27971 name: 'bold', 27972 text: 'Bold', 27973 action: 'Bold', 27974 icon: 'bold', 27975 shortcut: 'Meta+B' 27976 }, 27977 { 27978 name: 'italic', 27979 text: 'Italic', 27980 action: 'Italic', 27981 icon: 'italic', 27982 shortcut: 'Meta+I' 27983 }, 27984 { 27985 name: 'underline', 27986 text: 'Underline', 27987 action: 'Underline', 27988 icon: 'underline', 27989 shortcut: 'Meta+U' 27990 }, 27991 { 27992 name: 'strikethrough', 27993 text: 'Strikethrough', 27994 action: 'Strikethrough', 27995 icon: 'strike-through', 27996 shortcut: '' 27997 }, 27998 { 27999 name: 'subscript', 28000 text: 'Subscript', 28001 action: 'Subscript', 28002 icon: 'subscript', 28003 shortcut: '' 28004 }, 28005 { 28006 name: 'superscript', 28007 text: 'Superscript', 28008 action: 'Superscript', 28009 icon: 'superscript', 28010 shortcut: '' 28011 }, 28012 { 28013 name: 'removeformat', 28014 text: 'Clear formatting', 28015 action: 'RemoveFormat', 28016 icon: 'remove-formatting', 28017 shortcut: '' 28018 }, 28019 { 28020 name: 'newdocument', 28021 text: 'New document', 28022 action: 'mceNewDocument', 28023 icon: 'new-document', 28024 shortcut: '' 28025 }, 28026 { 28027 name: 'cut', 28028 text: 'Cut', 28029 action: 'Cut', 28030 icon: 'cut', 28031 shortcut: 'Meta+X' 28032 }, 28033 { 28034 name: 'copy', 28035 text: 'Copy', 28036 action: 'Copy', 28037 icon: 'copy', 28038 shortcut: 'Meta+C' 28039 }, 28040 { 28041 name: 'paste', 28042 text: 'Paste', 28043 action: 'Paste', 28044 icon: 'paste', 28045 shortcut: 'Meta+V' 28046 }, 28047 { 28048 name: 'selectall', 28049 text: 'Select all', 28050 action: 'SelectAll', 28051 icon: 'select-all', 28052 shortcut: 'Meta+A' 28053 } 28054 ], function (btn) { 28055 editor.ui.registry.addMenuItem(btn.name, { 28056 text: btn.text, 28057 icon: btn.icon, 28058 shortcut: btn.shortcut, 28059 onAction: function () { 28060 return editor.execCommand(btn.action); 28061 } 28062 }); 28063 }); 28064 editor.ui.registry.addMenuItem('codeformat', { 28065 text: 'Code', 28066 icon: 'sourcecode', 28067 onAction: toggleFormat(editor, 'code') 28068 }); 28069 }; 28070 var register$9 = function (editor) { 28071 registerButtons$2(editor); 28072 registerMenuItems$1(editor); 28073 }; 28074 28075 var toggleUndoRedoState = function (api, editor, type) { 28076 var checkState = function () { 28077 return editor.undoManager ? editor.undoManager[type]() : false;
28078 }; 28079 var onUndoStateChange = function () { 28080 api.setDisabled(editor.mode.isReadOnly() || !checkState()); 28081 }; 28082 api.setDisabled(!checkState()); 28083 editor.on('Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', onUndoStateChange); 28084 return function () { 28085 return editor.off('Undo Redo AddUndo TypingUndo ClearUndos SwitchMode', onUndoStateChange); 28086 }; 28087 }; 28088 var registerMenuItems$2 = function (editor) { 28089 editor.ui.registry.addMenuItem('undo', { 28090 text: 'Undo', 28091 icon: 'undo', 28092 shortcut: 'Meta+Z', 28093 onSetup: function (api) { 28094 return toggleUndoRedoState(api, editor, 'hasUndo'); 28095 }, 28096 onAction: function () { 28097 return editor.execCommand('undo'); 28098 } 28099 }); 28100 editor.ui.registry.addMenuItem('redo', { 28101 text: 'Redo', 28102 icon: 'redo', 28103 shortcut: 'Meta+Y', 28104 onSetup: function (api) { 28105 return toggleUndoRedoState(api, editor, 'hasRedo'); 28106 }, 28107 onAction: function () { 28108 return editor.execCommand('redo'); 28109 } 28110 }); 28111 }; 28112 var registerButtons$3 = function (editor) { 28113 editor.ui.registry.addButton('undo', { 28114 tooltip: 'Undo', 28115 icon: 'undo', 28116 onSetup: function (api) { 28117 return toggleUndoRedoState(api, editor, 'hasUndo'); 28118 }, 28119 onAction: function () { 28120 return editor.execCommand('undo'); 28121 } 28122 }); 28123 editor.ui.registry.addButton('redo', { 28124 tooltip: 'Redo', 28125 icon: 'redo', 28126 onSetup: function (api) { 28127 return toggleUndoRedoState(api, editor, 'hasRedo'); 28128 }, 28129 onAction: function () { 28130 return editor.execCommand('redo'); 28131 } 28132 }); 28133 }; 28134 var register$a = function (editor) { 28135 registerMenuItems$2(editor); 28136 registerButtons$3(editor); 28137 }; 28138 28139 var toggleVisualAidState = function (api, editor) { 28140 api.setActive(editor.hasVisual); 28141 var onVisualAid = function (e) { 28142 api.setActive(e.hasVisual); 28143 }; 28144 editor.on('VisualAid', onVisualAid); 28145 return function () { 28146 return editor.off('VisualAid', onVisualAid); 28147 }; 28148 }; 28149 var registerMenuItems$3 = function (editor) { 28150 editor.ui.registry.addToggleMenuItem('visualaid', { 28151 text: 'Visual aids', 28152 onSetup: function (api) { 28153 return toggleVisualAidState(api, editor); 28154 }, 28155 onAction: function () { 28156 editor.execCommand('mceToggleVisualAid'); 28157 } 28158 }); 28159 }; 28160 var registerToolbarButton = function (editor) { 28161 editor.ui.registry.addButton('visualaid', { 28162 tooltip: 'Visual aids', 28163 text: 'Visual aids', 28164 onAction: function () { 28165 return editor.execCommand('mceToggleVisualAid'); 28166 } 28167 }); 28168 }; 28169 var register$b = function (editor) { 28170 registerToolbarButton(editor); 28171 registerMenuItems$3(editor); 28172 }; 28173 28174 var setup$8 = function (editor, backstage) { 28175 register$5(editor); 28176 register$9(editor); 28177 register$6(editor, backstage); 28178 register$a(editor); 28179 register$1(editor); 28180 register$b(editor); 28181 register$7(editor); 28182 register$8(editor); 28183 }; 28184 28185 var nu$d = function (x, y) { 28186 return { 28187 anchor: 'makeshift', 28188 x: x, 28189 y: y 28190 }; 28191 }; 28192 var transpose$1 = function (pos, dx, dy) { 28193 return nu$d(pos.x + dx, pos.y + dy); 28194 }; 28195 var isTouchEvent$1 = function (e) { 28196 return e.type === 'longpress' || e.type.indexOf('touch') === 0; 28197 }; 28198 var fromPageXY = function (e) { 28199 if (isTouchEvent$1(e)) { 28200 var touch = e.touches[0]; 28201 return nu$d(touch.pageX, touch.pageY); 28202 } else { 28203 return nu$d(e.pageX, e.pageY); 28204 } 28205 }; 28206 var fromClientXY = function (e) { 28207 if (isTouchEvent$1(e)) { 28208 var touch = e.touches[0]; 28209 return nu$d(touch.clientX, touch.clientY); 28210 } else { 28211 return nu$d(e.clientX, e.clientY); 28212 } 28213 }; 28214 var transposeContentAreaContainer = function (element, pos) { 28215 var containerPos = global$5.DOM.getPos(element); 28216 return transpose$1(pos, containerPos.x, containerPos.y); 28217 }; 28218 var getPointAnchor = function (editor, e) { 28219 if (e.type === 'contextmenu' || e.type === 'longpress') { 28220 if (editor.inline) { 28221 return fromPageXY(e); 28222 } else { 28223 return transposeContentAreaContainer(editor.getContentAreaContainer(), fromClientXY(e)); 28224 } 28225 } else { 28226 return getSelectionAnchor(editor); 28227 } 28228 }; 28229 var getSelectionAnchor = function (editor) { 28230 return { 28231 anchor: 'selection', 28232 root: SugarElement.fromDom(editor.selection.getNode()) 28233 }; 28234 }; 28235 var getNodeAnchor$1 = function (editor) { 28236 return { 28237 anchor: 'node', 28238 node: Optional.some(SugarElement.fromDom(editor.selection.getNode())), 28239 root: SugarElement.fromDom(editor.getBody()) 28240 }; 28241 }; 28242 28243 var initAndShow = function (editor, e, buildMenu, backstage, contextmenu, useNodeAnchor) { 28244 var items = buildMenu(); 28245 var anchorSpec = useNodeAnchor ? getNodeAnchor$1(editor) : getPointAnchor(editor, e); 28246 build$2(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, false).map(function (menuData) { 28247 e.preventDefault(); 28248 InlineView.showMenuAt(contextmenu, anchorSpec, { 28249 menu: { markers: markers$1('normal') }, 28250 data: menuData 28251 }); 28252 }); 28253 }; 28254 28255 var layouts = { 28256 onLtr: function () { 28257 return [ 28258 south$1, 28259 southeast$1, 28260 southwest$1, 28261 northeast$1, 28262 northwest$1, 28263 north$1, 28264 north$3, 28265 south$3, 28266 northeast$3, 28267 southeast$3, 28268 northwest$3, 28269 southwest$3 28270 ]; 28271 }, 28272 onRtl: function () { 28273 return [ 28274 south$1, 28275 southwest$1, 28276 southeast$1, 28277 northwest$1, 28278 northeast$1, 28279 north$1, 28280 north$3, 28281 south$3, 28282 northwest$3, 28283 southwest$3, 28284 northeast$3, 28285 southeast$3 28286 ]; 28287 } 28288 }; 28289 var bubbleSize$1 = 12; 28290 var bubbleAlignments$2 = { 28291 valignCentre: [], 28292 alignCentre: [], 28293 alignLeft: ['tox-pop--align-left'], 28294 alignRight: ['tox-pop--align-right'], 28295 right: ['tox-pop--right'], 28296 left: ['tox-pop--left'], 28297 bottom: ['tox-pop--bottom'], 28298 top: ['tox-pop--top'] 28299 }; 28300 var isTouchWithinSelection = function (editor, e) { 28301 var selection = editor.selection; 28302 if (selection.isCollapsed() || e.touches.length < 1) { 28303 return false;
28304 } else { 28305 var touch_1 = e.touches[0]; 28306 var rng = selection.getRng(); 28307 var rngRectOpt = getFirstRect$1(editor.getWin(), SimSelection.domRange(rng)); 28308 return rngRectOpt.exists(function (rngRect) { 28309 return rngRect.left <= touch_1.clientX && rngRect.right >= touch_1.clientX && rngRect.top <= touch_1.clientY && rngRect.bottom >= touch_1.clientY; 28310 }); 28311 } 28312 }; 28313 var getPointAnchorSpec = function (editor, e) { 28314 return __assign({ 28315 bubble: nu$8(0, bubbleSize$1, bubbleAlignments$2), 28316 layouts: layouts, 28317 overrides: { 28318 maxWidthFunction: expandable$1(), 28319 maxHeightFunction: expandable() 28320 } 28321 }, getPointAnchor(editor, e)); 28322 }; 28323 var setupiOSOverrides = function (editor) { 28324 var originalSelection = editor.selection.getRng(); 28325 var selectionReset = function () { 28326 global$2.setEditorTimeout(editor, function () { 28327 editor.selection.setRng(originalSelection); 28328 }, 10); 28329 unbindEventListeners(); 28330 }; 28331 editor.once('touchend', selectionReset); 28332 var preventMousedown = function (e) { 28333 e.preventDefault(); 28334 e.stopImmediatePropagation(); 28335 }; 28336 editor.on('mousedown', preventMousedown, true); 28337 var clearSelectionReset = function () { 28338 return unbindEventListeners(); 28339 }; 28340 editor.once('longpresscancel', clearSelectionReset); 28341 var unbindEventListeners = function () { 28342 editor.off('touchend', selectionReset); 28343 editor.off('longpresscancel', clearSelectionReset); 28344 editor.off('mousedown', preventMousedown); 28345 }; 28346 }; 28347 var show = function (editor, e, items, backstage, contextmenu, useNodeAnchor, highlightImmediately) { 28348 var anchorSpec = useNodeAnchor ? getNodeAnchor$1(editor) : getPointAnchorSpec(editor, e); 28349 build$2(items, ItemResponse$1.CLOSE_ON_EXECUTE, backstage, true).map(function (menuData) { 28350 e.preventDefault(); 28351 InlineView.showMenuWithinBounds(contextmenu, anchorSpec, { 28352 menu: { 28353 markers: markers$1('normal'), 28354 highlightImmediately: highlightImmediately 28355 }, 28356 data: menuData, 28357 type: 'horizontal' 28358 }, function () { 28359 return Optional.some(getContextToolbarBounds(editor, backstage.shared)); 28360 }); 28361 editor.fire(hideContextToolbarEvent); 28362 }); 28363 }; 28364 var initAndShow$1 = function (editor, e, buildMenu, backstage, contextmenu, useNodeAnchor) { 28365 var detection = detect$3(); 28366 var isiOS = detection.os.isiOS(); 28367 var isOSX = detection.os.isOSX(); 28368 var isAndroid = detection.os.isAndroid(); 28369 var isTouch = detection.deviceType.isTouch(); 28370 var shouldHighlightImmediately = function () { 28371 return !(isAndroid || isiOS || isOSX && isTouch); 28372 }; 28373 var open = function () { 28374 var items = buildMenu(); 28375 show(editor, e, items, backstage, contextmenu, useNodeAnchor, shouldHighlightImmediately()); 28376 }; 28377 if ((isOSX || isiOS) && !useNodeAnchor) { 28378 var openiOS_1 = function () { 28379 setupiOSOverrides(editor); 28380 open(); 28381 }; 28382 if (isTouchWithinSelection(editor, e)) { 28383 openiOS_1(); 28384 } else { 28385 editor.once('selectionchange', openiOS_1); 28386 editor.once('touchend', function () { 28387 return editor.off('selectionchange', openiOS_1); 28388 }); 28389 } 28390 } else { 28391 if (isAndroid && !useNodeAnchor) { 28392 editor.selection.setCursorLocation(e.target, 0); 28393 } 28394 open(); 28395 } 28396 }; 28397 28398 var patchPipeConfig = function (config) { 28399 return typeof config === 'string' ? config.split(/[ ,]/) : config; 28400 }; 28401 var shouldNeverUseNative = function (editor) { 28402 return editor.getParam('contextmenu_never_use_native', false, 'boolean'); 28403 }; 28404 var getMenuItems = function (editor, name, defaultItems) { 28405 var contextMenus = editor.ui.registry.getAll().contextMenus; 28406 return Optional.from(editor.getParam(name)).map(patchPipeConfig).getOrThunk(function () { 28407 return filter(patchPipeConfig(defaultItems), function (item) { 28408 return has(contextMenus, item); 28409 }); 28410 }); 28411 }; 28412 var isContextMenuDisabled = function (editor) { 28413 return editor.getParam('contextmenu') === false; 28414 }; 28415 var getContextMenu = function (editor) { 28416 return getMenuItems(editor, 'contextmenu', 'link linkchecker image imagetools table spellchecker configurepermanentpen'); 28417 }; 28418 var getAvoidOverlapSelector = function (editor) { 28419 return editor.getParam('contextmenu_avoid_overlap', '', 'string'); 28420 }; 28421 28422 var isSeparator$1 = function (item) { 28423 return isString(item) ? item === '|' : item.type === 'separator'; 28424 }; 28425 var separator$3 = { type: 'separator' }; 28426 var makeContextItem = function (item) { 28427 var commonMenuItem = function (item) { 28428 return { 28429 text: item.text, 28430 icon: item.icon, 28431 disabled: item.disabled, 28432 shortcut: item.shortcut 28433 }; 28434 }; 28435 if (isString(item)) { 28436 return item; 28437 } else { 28438 switch (item.type) { 28439 case 'separator': 28440 return separator$3; 28441 case 'submenu': 28442 return __assign(__assign({ type: 'nestedmenuitem' }, commonMenuItem(item)), { 28443 getSubmenuItems: function () { 28444 var items = item.getSubmenuItems(); 28445 if (isString(items)) { 28446 return items; 28447 } else { 28448 return map(items, makeContextItem); 28449 } 28450 } 28451 }); 28452 default: 28453 return __assign(__assign({ type: 'menuitem' }, commonMenuItem(item)), { onAction: noarg(item.onAction) }); 28454 } 28455 } 28456 }; 28457 var addContextMenuGroup = function (xs, groupItems) { 28458 if (groupItems.length === 0) { 28459 return xs; 28460 } 28461 var lastMenuItem = last(xs).filter(function (item) { 28462 return !isSeparator$1(item); 28463 }); 28464 var before = lastMenuItem.fold(function () { 28465 return []; 28466 }, function (_) { 28467 return [separator$3]; 28468 }); 28469 return xs.concat(before).concat(groupItems).concat([separator$3]); 28470 }; 28471 var generateContextMenu = function (contextMenus, menuConfig, selectedElement) { 28472 var sections = foldl(menuConfig, function (acc, name) { 28473 return get$1(contextMenus, name.toLowerCase()).map(function (menu) { 28474 var items = menu.update(selectedElement); 28475 if (isString(items)) { 28476 return addContextMenuGroup(acc, items.split(' ')); 28477 } else if (items.length > 0) { 28478 var allItems = map(items, makeContextItem); 28479 return addContextMenuGroup(acc, allItems); 28480 } else { 28481 return acc; 28482 } 28483 }).getOrThunk(function () { 28484 return acc.concat([name]); 28485 }); 28486 }, []); 28487 if (sections.length > 0 && isSeparator$1(sections[sections.length - 1])) { 28488 sections.pop(); 28489 } 28490 return sections; 28491 }; 28492 var isNativeOverrideKeyEvent = function (editor, e) { 28493 return e.ctrlKey && !shouldNeverUseNative(editor); 28494 }; 28495 var isTriggeredByKeyboard = function (editor, e) { 28496 return e.type !== 'longpress' && (e.button !== 2 || e.target === editor.getBody() && e.pointerType === ''); 28497 }; 28498 var getSelectedElement = function (editor, e) { 28499 return isTriggeredByKeyboard(editor, e) ? editor.selection.getStart(true) : e.target; 28500 }; 28501 var shouldUseNodeAnchor = function (editor, e) { 28502 var selector = getAvoidOverlapSelector(editor); 28503 if (isTriggeredByKeyboard(editor, e)) { 28504 return true; 28505 } else if (selector) { 28506 var target = getSelectedElement(editor, e); 28507 return closest$4(SugarElement.fromDom(target), selector); 28508 } else { 28509 return false;
28510 } 28511 }; 28512 var setup$9 = function (editor, lazySink, backstage) { 28513 var detection = detect$3(); 28514 var isTouch = detection.deviceType.isTouch; 28515 var contextmenu = build$1(InlineView.sketch({ 28516 dom: { tag: 'div' }, 28517 lazySink: lazySink, 28518 onEscape: function () { 28519 return editor.focus(); 28520 }, 28521 onShow: function () { 28522 return backstage.setContextMenuState(true); 28523 }, 28524 onHide: function () { 28525 return backstage.setContextMenuState(false); 28526 }, 28527 fireDismissalEventInstead: {}, 28528 inlineBehaviours: derive$1([config('dismissContextMenu', [run(dismissRequested(), function (comp, _se) { 28529 Sandboxing.close(comp); 28530 editor.focus(); 28531 })])]) 28532 })); 28533 var hideContextMenu = function (_e) { 28534 return InlineView.hide(contextmenu); 28535 }; 28536 var showContextMenu = function (e) { 28537 if (shouldNeverUseNative(editor)) { 28538 e.preventDefault(); 28539 } 28540 if (isNativeOverrideKeyEvent(editor, e) || isContextMenuDisabled(editor)) { 28541 return; 28542 } 28543 var useNodeAnchor = shouldUseNodeAnchor(editor, e); 28544 var buildMenu = function () { 28545 var selectedElement = getSelectedElement(editor, e); 28546 var registry = editor.ui.registry.getAll(); 28547 var menuConfig = getContextMenu(editor); 28548 return generateContextMenu(registry.contextMenus, menuConfig, selectedElement); 28549 }; 28550 var initAndShow$2 = isTouch() ? initAndShow$1 : initAndShow; 28551 initAndShow$2(editor, e, buildMenu, backstage, contextmenu, useNodeAnchor); 28552 }; 28553 editor.on('init', function () { 28554 var hideEvents = 'ResizeEditor ScrollContent ScrollWindow longpresscancel' + (isTouch() ? '' : ' ResizeWindow'); 28555 editor.on(hideEvents, hideContextMenu); 28556 editor.on('longpress contextmenu', showContextMenu); 28557 }); 28558 }; 28559 28560 var adt$c = Adt.generate([ 28561 { 28562 offset: [ 28563 'x', 28564 'y' 28565 ] 28566 }, 28567 { 28568 absolute: [ 28569 'x', 28570 'y' 28571 ] 28572 }, 28573 { 28574 fixed: [ 28575 'x', 28576 'y' 28577 ] 28578 } 28579 ]); 28580 var subtract = function (change) { 28581 return function (point) { 28582 return point.translate(-change.left, -change.top); 28583 }; 28584 }; 28585 var add$4 = function (change) { 28586 return function (point) { 28587 return point.translate(change.left, change.top); 28588 }; 28589 }; 28590 var transform$1 = function (changes) { 28591 return function (x, y) { 28592 return foldl(changes, function (rest, f) { 28593 return f(rest); 28594 }, SugarPosition(x, y)); 28595 }; 28596 }; 28597 var asFixed = function (coord, scroll, origin) { 28598 return coord.fold(transform$1([ 28599 add$4(origin), 28600 subtract(scroll) 28601 ]), transform$1([subtract(scroll)]), transform$1([])); 28602 }; 28603 var asAbsolute = function (coord, scroll, origin) { 28604 return coord.fold(transform$1([add$4(origin)]), transform$1([]), transform$1([add$4(scroll)])); 28605 }; 28606 var asOffset = function (coord, scroll, origin) { 28607 return coord.fold(transform$1([]), transform$1([subtract(origin)]), transform$1([ 28608 add$4(scroll), 28609 subtract(origin) 28610 ])); 28611 }; 28612 var withinRange = function (coord1, coord2, xRange, yRange, scroll, origin) { 28613 var a1 = asAbsolute(coord1, scroll, origin); 28614 var a2 = asAbsolute(coord2, scroll, origin); 28615 return Math.abs(a1.left - a2.left) <= xRange && Math.abs(a1.top - a2.top) <= yRange; 28616 }; 28617 var getDeltas = function (coord1, coord2, xRange, yRange, scroll, origin) { 28618 var a1 = asAbsolute(coord1, scroll, origin); 28619 var a2 = asAbsolute(coord2, scroll, origin); 28620 var left = Math.abs(a1.left - a2.left); 28621 var top = Math.abs(a1.top - a2.top); 28622 return SugarPosition(left, top); 28623 }; 28624 var toStyles = function (coord, scroll, origin) { 28625 var stylesOpt = coord.fold(function (x, y) { 28626 return { 28627 position: Optional.some('absolute'), 28628 left: Optional.some(x + 'px'), 28629 top: Optional.some(y + 'px') 28630 }; 28631 }, function (x, y) { 28632 return { 28633 position: Optional.some('absolute'), 28634 left: Optional.some(x - origin.left + 'px'), 28635 top: Optional.some(y - origin.top + 'px') 28636 }; 28637 }, function (x, y) { 28638 return { 28639 position: Optional.some('fixed'), 28640 left: Optional.some(x + 'px'), 28641 top: Optional.some(y + 'px') 28642 }; 28643 }); 28644 return __assign({ 28645 right: Optional.none(), 28646 bottom: Optional.none() 28647 }, stylesOpt); 28648 }; 28649 var translate$2 = function (coord, deltaX, deltaY) { 28650 return coord.fold(function (x, y) { 28651 return offset(x + deltaX, y + deltaY); 28652 }, function (x, y) { 28653 return absolute$3(x + deltaX, y + deltaY); 28654 }, function (x, y) { 28655 return fixed$1(x + deltaX, y + deltaY); 28656 }); 28657 }; 28658 var absorb = function (partialCoord, originalCoord, scroll, origin) { 28659 var absorbOne = function (stencil, nu) { 28660 return function (optX, optY) { 28661 var original = stencil(originalCoord, scroll, origin); 28662 return nu(optX.getOr(original.left), optY.getOr(original.top)); 28663 }; 28664 }; 28665 return partialCoord.fold(absorbOne(asOffset, offset), absorbOne(asAbsolute, absolute$3), absorbOne(asFixed, fixed$1)); 28666 }; 28667 var offset = adt$c.offset; 28668 var absolute$3 = adt$c.absolute; 28669 var fixed$1 = adt$c.fixed; 28670 28671 var parseAttrToInt = function (element, name) { 28672 var value = get$3(element, name); 28673 return isUndefined(value) ? NaN : parseInt(value, 10); 28674 }; 28675 var get$f = function (component, snapsInfo) { 28676 var element = component.element; 28677 var x = parseAttrToInt(element, snapsInfo.leftAttr); 28678 var y = parseAttrToInt(element, snapsInfo.topAttr); 28679 return isNaN(x) || isNaN(y) ? Optional.none() : Optional.some(SugarPosition(x, y)); 28680 }; 28681 var set$8 = function (component, snapsInfo, pt) { 28682 var element = component.element; 28683 set$1(element, snapsInfo.leftAttr, pt.left + 'px'); 28684 set$1(element, snapsInfo.topAttr, pt.top + 'px'); 28685 }; 28686 var clear = function (component, snapsInfo) { 28687 var element = component.element; 28688 remove$1(element, snapsInfo.leftAttr); 28689 remove$1(element, snapsInfo.topAttr); 28690 }; 28691 28692 var getCoords = function (component, snapInfo, coord, delta) { 28693 return get$f(component, snapInfo).fold(function () { 28694 return coord; 28695 }, function (fixed) { 28696 return fixed$1(fixed.left + delta.left, fixed.top + delta.top); 28697 }); 28698 }; 28699 var moveOrSnap = function (component, snapInfo, coord, delta, scroll, origin) { 28700 var newCoord = getCoords(component, snapInfo, coord, delta); 28701 var snap = snapInfo.mustSnap ? findClosestSnap(component, snapInfo, newCoord, scroll, origin) : findSnap(component, snapInfo, newCoord, scroll, origin); 28702 var fixedCoord = asFixed(newCoord, scroll, origin); 28703 set$8(component, snapInfo, fixedCoord); 28704 return snap.fold(function () { 28705 return { 28706 coord: fixed$1(fixedCoord.left, fixedCoord.top), 28707 extra: Optional.none() 28708 }; 28709 }, function (spanned) { 28710 return { 28711 coord: spanned.output, 28712 extra: spanned.extra 28713 }; 28714 }); 28715 }; 28716 var stopDrag = function (component, snapInfo) { 28717 clear(component, snapInfo); 28718 }; 28719 var findMatchingSnap = function (snaps, newCoord, scroll, origin) { 28720 return findMap(snaps, function (snap) { 28721 var sensor = snap.sensor; 28722 var inRange = withinRange(newCoord, sensor, snap.range.left, snap.range.top, scroll, origin); 28723 return inRange ? Optional.some({ 28724 output: absorb(snap.output, newCoord, scroll, origin), 28725 extra: snap.extra 28726 }) : Optional.none(); 28727 }); 28728 }; 28729 var findClosestSnap = function (component, snapInfo, newCoord, scroll, origin) { 28730 var snaps = snapInfo.getSnapPoints(component); 28731 var matchSnap = findMatchingSnap(snaps, newCoord, scroll, origin); 28732 return matchSnap.orThunk(function () { 28733 var bestSnap = foldl(snaps, function (acc, snap) { 28734 var sensor = snap.sensor; 28735 var deltas = getDeltas(newCoord, sensor, snap.range.left, snap.range.top, scroll, origin); 28736 return acc.deltas.fold(function () { 28737 return { 28738 deltas: Optional.some(deltas), 28739 snap: Optional.some(snap) 28740 }; 28741 }, function (bestDeltas) { 28742 var currAvg = (deltas.left + deltas.top) / 2; 28743 var bestAvg = (bestDeltas.left + bestDeltas.top) / 2; 28744 if (currAvg <= bestAvg) { 28745 return { 28746 deltas: Optional.some(deltas), 28747 snap: Optional.some(snap) 28748 }; 28749 } else { 28750 return acc; 28751 } 28752 }); 28753 }, { 28754 deltas: Optional.none(), 28755 snap: Optional.none() 28756 }); 28757 return bestSnap.snap.map(function (snap) { 28758 return { 28759 output: absorb(snap.output, newCoord, scroll, origin), 28760 extra: snap.extra 28761 }; 28762 }); 28763 }); 28764 }; 28765 var findSnap = function (component, snapInfo, newCoord, scroll, origin) { 28766 var snaps = snapInfo.getSnapPoints(component); 28767 return findMatchingSnap(snaps, newCoord, scroll, origin); 28768 }; 28769 var snapTo = function (snap, scroll, origin) { 28770 return { 28771 coord: absorb(snap.output, snap.output, scroll, origin), 28772 extra: snap.extra 28773 }; 28774 }; 28775 28776 var snapTo$1 = function (component, dragConfig, _state, snap) { 28777 var target = dragConfig.getTarget(component.element); 28778 if (dragConfig.repositionTarget) { 28779 var doc = owner(component.element); 28780 var scroll_1 = get$9(doc); 28781 var origin_1 = getOrigin(target); 28782 var snapPin = snapTo(snap, scroll_1, origin_1); 28783 var styles = toStyles(snapPin.coord, scroll_1, origin_1); 28784 setOptions(target, styles); 28785 } 28786 }; 28787 28788 var DraggingApis = /*#__PURE__*/Object.freeze({ 28789 __proto__: null,
28790 snapTo: snapTo$1 28791 }); 28792 28793 var initialAttribute = 'data-initial-z-index'; 28794 var resetZIndex = function (blocker) { 28795 parent(blocker.element).filter(isElement).each(function (root) { 28796 getOpt(root, initialAttribute).fold(function () { 28797 return remove$6(root, 'z-index'); 28798 }, function (zIndex) { 28799 return set$2(root, 'z-index', zIndex); 28800 }); 28801 remove$1(root, initialAttribute); 28802 }); 28803 }; 28804 var changeZIndex = function (blocker) { 28805 parent(blocker.element).filter(isElement).each(function (root) { 28806 getRaw(root, 'z-index').each(function (zindex) { 28807 set$1(root, initialAttribute, zindex); 28808 }); 28809 set$2(root, 'z-index', get$5(blocker.element, 'z-index')); 28810 }); 28811 }; 28812 var instigate = function (anyComponent, blocker) { 28813 anyComponent.getSystem().addToGui(blocker); 28814 changeZIndex(blocker); 28815 }; 28816 var discard = function (blocker) { 28817 resetZIndex(blocker); 28818 blocker.getSystem().removeFromGui(blocker); 28819 }; 28820 var createComponent = function (component, blockerClass, blockerEvents) { 28821 return component.getSystem().build(Container.sketch({ 28822 dom: { 28823 styles: { 28824 'left': '0px', 28825 'top': '0px', 28826 'width': '100%', 28827 'height': '100%', 28828 'position': 'fixed', 28829 'z-index': '1000000000000000' 28830 }, 28831 classes: [blockerClass] 28832 }, 28833 events: blockerEvents 28834 })); 28835 }; 28836 28837 var SnapSchema = optionObjOf('snaps', [ 28838 strict$1('getSnapPoints'), 28839 onHandler('onSensor'), 28840 strict$1('leftAttr'), 28841 strict$1('topAttr'), 28842 defaulted$1('lazyViewport', win), 28843 defaulted$1('mustSnap', false) 28844 ]); 28845 28846 var schema$t = [ 28847 defaulted$1('useFixed', never), 28848 strict$1('blockerClass'), 28849 defaulted$1('getTarget', identity), 28850 defaulted$1('onDrag', noop), 28851 defaulted$1('repositionTarget', true), 28852 defaulted$1('onDrop', noop), 28853 defaultedFunction('getBounds', win), 28854 SnapSchema 28855 ]; 28856 28857 var getCurrentCoord = function (target) { 28858 return lift3(getRaw(target, 'left'), getRaw(target, 'top'), getRaw(target, 'position'), function (left, top, position) { 28859 var nu = position === 'fixed' ? fixed$1 : offset; 28860 return nu(parseInt(left, 10), parseInt(top, 10)); 28861 }).getOrThunk(function () { 28862 var location = absolute(target); 28863 return absolute$3(location.left, location.top); 28864 }); 28865 }; 28866 var clampCoords = function (component, coords, scroll, origin, startData) { 28867 var bounds = startData.bounds; 28868 var absoluteCoord = asAbsolute(coords, scroll, origin); 28869 var newX = clamp(absoluteCoord.left, bounds.x, bounds.x + bounds.width - startData.width); 28870 var newY = clamp(absoluteCoord.top, bounds.y, bounds.y + bounds.height - startData.height); 28871 var newCoords = absolute$3(newX, newY); 28872 return coords.fold(function () { 28873 var offset$1 = asOffset(newCoords, scroll, origin); 28874 return offset(offset$1.left, offset$1.top); 28875 }, function () { 28876 return newCoords; 28877 }, function () { 28878 var fixed = asFixed(newCoords, scroll, origin); 28879 return fixed$1(fixed.left, fixed.top); 28880 }); 28881 }; 28882 var calcNewCoord = function (component, optSnaps, currentCoord, scroll, origin, delta, startData) { 28883 var newCoord = optSnaps.fold(function () { 28884 var translated = translate$2(currentCoord, delta.left, delta.top); 28885 var fixedCoord = asFixed(translated, scroll, origin); 28886 return fixed$1(fixedCoord.left, fixedCoord.top); 28887 }, function (snapInfo) { 28888 var snapping = moveOrSnap(component, snapInfo, currentCoord, delta, scroll, origin); 28889 snapping.extra.each(function (extra) { 28890 snapInfo.onSensor(component, extra); 28891 }); 28892 return snapping.coord; 28893 }); 28894 return clampCoords(component, newCoord, scroll, origin, startData); 28895 }; 28896 var dragBy = function (component, dragConfig, startData, delta) { 28897 var target = dragConfig.getTarget(component.element); 28898 if (dragConfig.repositionTarget) { 28899 var doc = owner(component.element); 28900 var scroll_1 = get$9(doc); 28901 var origin_1 = getOrigin(target); 28902 var currentCoord = getCurrentCoord(target); 28903 var newCoord = calcNewCoord(component, dragConfig.snaps, currentCoord, scroll_1, origin_1, delta, startData); 28904 var styles = toStyles(newCoord, scroll_1, origin_1); 28905 setOptions(target, styles); 28906 } 28907 dragConfig.onDrag(component, target, delta); 28908 }; 28909 28910 var calcStartData = function (dragConfig, comp) { 28911 return { 28912 bounds: dragConfig.getBounds(), 28913 height: getOuter$1(comp.element), 28914 width: getOuter$2(comp.element) 28915 }; 28916 }; 28917 var move$1 = function (component, dragConfig, dragState, dragMode, event) { 28918 var delta = dragState.update(dragMode, event); 28919 var dragStartData = dragState.getStartData().getOrThunk(function () { 28920 return calcStartData(dragConfig, component); 28921 }); 28922 delta.each(function (dlt) { 28923 dragBy(component, dragConfig, dragStartData, dlt); 28924 }); 28925 }; 28926 var stop = function (component, blocker, dragConfig, dragState) { 28927 blocker.each(discard); 28928 dragConfig.snaps.each(function (snapInfo) { 28929 stopDrag(component, snapInfo); 28930 }); 28931 var target = dragConfig.getTarget(component.element); 28932 dragState.reset(); 28933 dragConfig.onDrop(component, target); 28934 }; 28935 var handlers = function (events) { 28936 return function (dragConfig, dragState) { 28937 var updateStartState = function (comp) { 28938 dragState.setStartData(calcStartData(dragConfig, comp)); 28939 }; 28940 return derive(__spreadArrays([run(windowScroll(), function (comp) { 28941 dragState.getStartData().each(function () { 28942 return updateStartState(comp); 28943 }); 28944 })], events(dragConfig, dragState, updateStartState))); 28945 }; 28946 }; 28947 28948 var init$c = function (dragApi) { 28949 return derive([ 28950 run(mousedown(), dragApi.forceDrop), 28951 run(mouseup(), dragApi.drop), 28952 run(mousemove(), function (comp, simulatedEvent) { 28953 dragApi.move(simulatedEvent.event); 28954 }), 28955 run(mouseout(), dragApi.delayDrop) 28956 ]); 28957 }; 28958 28959 var getData$1 = function (event) { 28960 return Optional.from(SugarPosition(event.x, event.y)); 28961 }; 28962 var getDelta$1 = function (old, nu) { 28963 return SugarPosition(nu.left - old.left, nu.top - old.top); 28964 }; 28965 28966 var MouseData = /*#__PURE__*/Object.freeze({ 28967 __proto__: null, 28968 getData: getData$1, 28969 getDelta: getDelta$1 28970 }); 28971 28972 var events$g = function (dragConfig, dragState, updateStartState) { 28973 return [run(mousedown(), function (component, simulatedEvent) { 28974 var raw = simulatedEvent.event.raw; 28975 if (raw.button !== 0) { 28976 return; 28977 } 28978 simulatedEvent.stop(); 28979 var stop$1 = function () { 28980 return stop(component, Optional.some(blocker), dragConfig, dragState); 28981 }; 28982 var delayDrop = DelayedFunction(stop$1, 200); 28983 var dragApi = { 28984 drop: stop$1, 28985 delayDrop: delayDrop.schedule, 28986 forceDrop: stop$1, 28987 move: function (event) { 28988 delayDrop.cancel(); 28989 move$1(component, dragConfig, dragState, MouseData, event); 28990 } 28991 }; 28992 var blocker = createComponent(component, dragConfig.blockerClass, init$c(dragApi)); 28993 var start = function () { 28994 updateStartState(component); 28995 instigate(component, blocker); 28996 }; 28997 start(); 28998 })]; 28999 }; 29000 var schema$u = __spreadArrays(schema$t, [output('dragger', { handlers: handlers(events$g) })]); 29001 29002 var init$d = function (dragApi) { 29003 return derive([ 29004 run(touchstart(), dragApi.forceDrop), 29005 run(touchend(), dragApi.drop), 29006 run(touchcancel(), dragApi.drop), 29007 run(touchmove(), function (comp, simulatedEvent) { 29008 dragApi.move(simulatedEvent.event); 29009 }) 29010 ]); 29011 }; 29012 29013 var getDataFrom = function (touches) { 29014 var touch = touches[0]; 29015 return Optional.some(SugarPosition(touch.clientX, touch.clientY)); 29016 }; 29017 var getData$2 = function (event) { 29018 var raw = event.raw; 29019 var touches = raw.touches; 29020 return touches.length === 1 ? getDataFrom(touches) : Optional.none(); 29021 }; 29022 var getDelta$2 = function (old, nu) { 29023 return SugarPosition(nu.left - old.left, nu.top - old.top); 29024 }; 29025 29026 var TouchData = /*#__PURE__*/Object.freeze({ 29027 __proto__: null, 29028 getData: getData$2, 29029 getDelta: getDelta$2 29030 }); 29031 29032 var events$h = function (dragConfig, dragState, updateStartState) { 29033 var blockerCell = Cell(Optional.none()); 29034 return [ 29035 run(touchstart(), function (component, simulatedEvent) { 29036 simulatedEvent.stop(); 29037 var stop$1 = function () { 29038 stop(component, blockerCell.get(), dragConfig, dragState); 29039 blockerCell.set(Optional.none()); 29040 }; 29041 var dragApi = { 29042 drop: stop$1, 29043 delayDrop: noop, 29044 forceDrop: stop$1, 29045 move: function (event) { 29046 move$1(component, dragConfig, dragState, TouchData, event); 29047 } 29048 }; 29049 var blocker = createComponent(component, dragConfig.blockerClass, init$d(dragApi)); 29050 blockerCell.set(Optional.some(blocker)); 29051 var start = function () { 29052 updateStartState(component); 29053 instigate(component, blocker); 29054 }; 29055 start(); 29056 }), 29057 run(touchmove(), function (component, simulatedEvent) { 29058 simulatedEvent.stop(); 29059 move$1(component, dragConfig, dragState, TouchData, simulatedEvent.event); 29060 }), 29061 run(touchend(), function (component, simulatedEvent) { 29062 simulatedEvent.stop(); 29063 stop(component, blockerCell.get(), dragConfig, dragState); 29064 blockerCell.set(Optional.none()); 29065 }), 29066 run(touchcancel(), function (component) { 29067 stop(component, blockerCell.get(), dragConfig, dragState); 29068 blockerCell.set(Optional.none()); 29069 }) 29070 ]; 29071 }; 29072 var schema$v = __spreadArrays(schema$t, [output('dragger', { handlers: handlers(events$h) })]); 29073 29074 var events$i = function (dragConfig, dragState, updateStartState) { 29075 return __spreadArrays(events$g(dragConfig, dragState, updateStartState), events$h(dragConfig, dragState, updateStartState)); 29076 }; 29077 var schema$w = __spreadArrays(schema$t, [output('dragger', { handlers: handlers(events$i) })]); 29078
29079 var mouse = schema$u; 29080 var touch = schema$v; 29081 var mouseOrTouch = schema$w; 29082 29083 var DraggingBranches = /*#__PURE__*/Object.freeze({ 29084 __proto__: null, 29085 mouse: mouse, 29086 touch: touch, 29087 mouseOrTouch: mouseOrTouch 29088 }); 29089 29090 var init$e = function () { 29091 var previous = Optional.none(); 29092 var startData = Optional.none(); 29093 var reset = function () { 29094 previous = Optional.none(); 29095 startData = Optional.none(); 29096 }; 29097 var calculateDelta = function (mode, nu) { 29098 var result = previous.map(function (old) { 29099 return mode.getDelta(old, nu); 29100 }); 29101 previous = Optional.some(nu); 29102 return result; 29103 }; 29104 var update = function (mode, dragEvent) { 29105 return mode.getData(dragEvent).bind(function (nuData) { 29106 return calculateDelta(mode, nuData); 29107 }); 29108 }; 29109 var setStartData = function (data) { 29110 startData = Optional.some(data); 29111 }; 29112 var getStartData = function () { 29113 return startData; 29114 }; 29115 var readState = constant({}); 29116 return nu$5({ 29117 readState: readState, 29118 reset: reset, 29119 update: update, 29120 getStartData: getStartData, 29121 setStartData: setStartData 29122 }); 29123 }; 29124 29125 var DragState = /*#__PURE__*/Object.freeze({ 29126 __proto__: null, 29127 init: init$e 29128 }); 29129 29130 var Dragging = createModes$1({ 29131 branchKey: 'mode', 29132 branches: DraggingBranches, 29133 name: 'dragging', 29134 active: { 29135 events: function (dragConfig, dragState) { 29136 var dragger = dragConfig.dragger; 29137 return dragger.handlers(dragConfig, dragState); 29138 } 29139 }, 29140 extra: { 29141 snap: function (sConfig) { 29142 return { 29143 sensor: sConfig.sensor, 29144 range: sConfig.range, 29145 output: sConfig.output, 29146 extra: Optional.from(sConfig.extra) 29147 }; 29148 } 29149 }, 29150 state: DragState, 29151 apis: DraggingApis 29152 }); 29153 29154 var snapWidth = 40; 29155 var snapOffset = snapWidth / 2; 29156 var calcSnap = function (selectorOpt, td, x, y, width, height) { 29157 return selectorOpt.fold(function () { 29158 return Dragging.snap({ 29159 sensor: absolute$3(x - snapOffset, y - snapOffset), 29160 range: SugarPosition(width, height), 29161 output: absolute$3(Optional.some(x), Optional.some(y)), 29162 extra: { td: td } 29163 }); 29164 }, function (selectorHandle) { 29165 var sensorLeft = x - snapOffset; 29166 var sensorTop = y - snapOffset; 29167 var sensorWidth = snapWidth; 29168 var sensorHeight = snapWidth; 29169 var rect = selectorHandle.element.dom.getBoundingClientRect(); 29170 return Dragging.snap({ 29171 sensor: absolute$3(sensorLeft, sensorTop), 29172 range: SugarPosition(sensorWidth, sensorHeight), 29173 output: absolute$3(Optional.some(x - rect.width / 2), Optional.some(y - rect.height / 2)), 29174 extra: { td: td } 29175 }); 29176 }); 29177 }; 29178 var getSnapsConfig = function (getSnapPoints, cell, onChange) { 29179 var isSameCell = function (cellOpt, td) { 29180 return cellOpt.exists(function (currentTd) { 29181 return eq$1(currentTd, td); 29182 }); 29183 }; 29184 return { 29185 getSnapPoints: getSnapPoints, 29186 leftAttr: 'data-drag-left', 29187 topAttr: 'data-drag-top', 29188 onSensor: function (component, extra) { 29189 var td = extra.td; 29190 if (!isSameCell(cell.get(), td)) { 29191 cell.set(Optional.some(td)); 29192 onChange(td); 29193 } 29194 }, 29195 mustSnap: true 29196 }; 29197 }; 29198 var createSelector = function (snaps) { 29199 return record(Button.sketch({ 29200 dom: { 29201 tag: 'div', 29202 classes: ['tox-selector'] 29203 }, 29204 buttonBehaviours: derive$1([ 29205 Dragging.config({ 29206 mode: 'mouseOrTouch', 29207 blockerClass: 'blocker', 29208 snaps: snaps 29209 }), 29210 Unselecting.config({}) 29211 ]), 29212 eventOrder: { 29213 mousedown: [ 29214 'dragging', 29215 'alloy.base.behaviour' 29216 ], 29217 touchstart: [ 29218 'dragging', 29219 'alloy.base.behaviour' 29220 ] 29221 } 29222 })); 29223 }; 29224 var setup$a = function (editor, sink) { 29225 var tlTds = Cell([]); 29226 var brTds = Cell([]); 29227 var isVisible = Cell(false); 29228 var startCell = Cell(Optional.none()); 29229 var finishCell = Cell(Optional.none()); 29230 var getTopLeftSnap = function (td) { 29231 var box = absolute$1(td); 29232 return calcSnap(memTopLeft.getOpt(sink), td, box.x, box.y, box.width, box.height); 29233 }; 29234 var getTopLeftSnaps = function () { 29235 return map(tlTds.get(), function (td) { 29236 return getTopLeftSnap(td); 29237 }); 29238 }; 29239 var getBottomRightSnap = function (td) { 29240 var box = absolute$1(td); 29241 return calcSnap(memBottomRight.getOpt(sink), td, box.right, box.bottom, box.width, box.height); 29242 }; 29243 var getBottomRightSnaps = function () { 29244 return map(brTds.get(), function (td) { 29245 return getBottomRightSnap(td); 29246 }); 29247 }; 29248 var topLeftSnaps = getSnapsConfig(getTopLeftSnaps, startCell, function (start) { 29249 finishCell.get().each(function (finish) { 29250 editor.fire('TableSelectorChange', { 29251 start: start, 29252 finish: finish 29253 }); 29254 }); 29255 }); 29256 var bottomRightSnaps = getSnapsConfig(getBottomRightSnaps, finishCell, function (finish) { 29257 startCell.get().each(function (start) { 29258 editor.fire('TableSelectorChange', { 29259 start: start, 29260 finish: finish 29261 }); 29262 }); 29263 }); 29264 var memTopLeft = createSelector(topLeftSnaps); 29265 var memBottomRight = createSelector(bottomRightSnaps); 29266 var topLeft = build$1(memTopLeft.asSpec()); 29267 var bottomRight = build$1(memBottomRight.asSpec()); 29268 var showOrHideHandle = function (selector, cell, isAbove, isBelow) { 29269 var cellRect = cell.dom.getBoundingClientRect(); 29270 remove$6(selector.element, 'display');
29271 var viewportHeight = defaultView(SugarElement.fromDom(editor.getBody())).dom.innerHeight; 29272 var aboveViewport = isAbove(cellRect); 29273 var belowViewport = isBelow(cellRect, viewportHeight); 29274 if (aboveViewport || belowViewport) { 29275 set$2(selector.element, 'display', 'none'); 29276 } 29277 }; 29278 var snapTo = function (selector, cell, getSnapConfig, pos) { 29279 var snap = getSnapConfig(cell); 29280 Dragging.snapTo(selector, snap); 29281 var isAbove = function (rect) { 29282 return rect[pos] < 0; 29283 }; 29284 var isBelow = function (rect, viewportHeight) { 29285 return rect[pos] > viewportHeight; 29286 }; 29287 showOrHideHandle(selector, cell, isAbove, isBelow); 29288 }; 29289 var snapTopLeft = function (cell) { 29290 return snapTo(topLeft, cell, getTopLeftSnap, 'top'); 29291 }; 29292 var snapLastTopLeft = function () { 29293 return startCell.get().each(snapTopLeft); 29294 }; 29295 var snapBottomRight = function (cell) { 29296 return snapTo(bottomRight, cell, getBottomRightSnap, 'bottom'); 29297 }; 29298 var snapLastBottomRight = function () { 29299 return finishCell.get().each(snapBottomRight); 29300 }; 29301 if (detect$3().deviceType.isTouch()) { 29302 editor.on('TableSelectionChange', function (e) { 29303 if (!isVisible.get()) { 29304 attach$1(sink, topLeft); 29305 attach$1(sink, bottomRight); 29306 isVisible.set(true); 29307 } 29308 startCell.set(Optional.some(e.start)); 29309 finishCell.set(Optional.some(e.finish)); 29310 e.otherCells.each(function (otherCells) { 29311 tlTds.set(otherCells.upOrLeftCells); 29312 brTds.set(otherCells.downOrRightCells); 29313 snapTopLeft(e.start); 29314 snapBottomRight(e.finish); 29315 }); 29316 }); 29317 editor.on('ResizeEditor ResizeWindow ScrollContent', function () { 29318 snapLastTopLeft(); 29319 snapLastBottomRight(); 29320 }); 29321 editor.on('TableSelectionClear', function () { 29322 if (isVisible.get()) { 29323 detach(topLeft); 29324 detach(bottomRight); 29325 isVisible.set(false); 29326 } 29327 startCell.set(Optional.none()); 29328 finishCell.set(Optional.none()); 29329 }); 29330 } 29331 }; 29332 29333 var isHidden$1 = function (elm) { 29334 if (elm.nodeType === 1) { 29335 if (elm.nodeName === 'BR' || !!elm.getAttribute('data-mce-bogus')) { 29336 return true; 29337 } 29338 if (elm.getAttribute('data-mce-type') === 'bookmark') { 29339 return true; 29340 } 29341 } 29342 return false; 29343 }; 29344 var renderElementPath = function (editor, settings, providersBackstage) { 29345 if (!settings.delimiter) { 29346 settings.delimiter = '\xBB'; 29347 } 29348 var getDataPath = function (data) { 29349 var parts = data || []; 29350 var newPathElements = map(parts, function (part, index) { 29351 return Button.sketch({ 29352 dom: { 29353 tag: 'div', 29354 classes: ['tox-statusbar__path-item'], 29355 attributes: { 29356 'role': 'button', 29357 'data-index': index, 29358 'tab-index': -1, 29359 'aria-level': index + 1 29360 }, 29361 innerHtml: part.name 29362 }, 29363 action: function (_btn) { 29364 editor.focus(); 29365 editor.selection.select(part.element); 29366 editor.nodeChanged(); 29367 }, 29368 buttonBehaviours: derive$1([ 29369 DisablingConfigs.button(providersBackstage.isDisabled), 29370 receivingConfig() 29371 ]) 29372 }); 29373 }); 29374 var divider = { 29375 dom: { 29376 tag: 'div', 29377 classes: ['tox-statusbar__path-divider'], 29378 attributes: { 'aria-hidden': true }, 29379 innerHtml: ' ' + settings.delimiter + ' ' 29380 } 29381 }; 29382 return foldl(newPathElements.slice(1), function (acc, element) { 29383 var newAcc = acc; 29384 newAcc.push(divider); 29385 newAcc.push(element); 29386 return newAcc; 29387 }, [newPathElements[0]]); 29388 }; 29389 var updatePath = function (parents) { 29390 var newPath = []; 29391 var i = parents.length; 29392 while (i-- > 0) { 29393 var parent_1 = parents[i];
29394 if (parent_1.nodeType === 1 && !isHidden$1(parent_1)) { 29395 var args = editor.fire('ResolveName', { 29396 name: parent_1.nodeName.toLowerCase(), 29397 target: parent_1 29398 }); 29399 if (!args.isDefaultPrevented()) { 29400 newPath.push({ 29401 name: args.name, 29402 element: parent_1 29403 }); 29404 } 29405 if (args.isPropagationStopped()) { 29406 break; 29407 } 29408 } 29409 } 29410 return newPath; 29411 }; 29412 return { 29413 dom: { 29414 tag: 'div', 29415 classes: ['tox-statusbar__path'], 29416 attributes: { role: 'navigation' } 29417 }, 29418 behaviours: derive$1([ 29419 Keying.config({ 29420 mode: 'flow', 29421 selector: 'div[role=button]' 29422 }), 29423 Disabling.config({ disabled: providersBackstage.isDisabled }), 29424 receivingConfig(), 29425 Tabstopping.config({}), 29426 Replacing.config({}), 29427 config('elementPathEvents', [runOnAttached(function (comp, _e) { 29428 editor.shortcuts.add('alt+F11', 'focus statusbar elementpath', function () { 29429 return Keying.focusIn(comp); 29430 }); 29431 editor.on('NodeChange', function (e) { 29432 var newPath = updatePath(e.parents); 29433 if (newPath.length > 0) { 29434 Replacing.set(comp, getDataPath(newPath)); 29435 } else { 29436 Replacing.set(comp, []); 29437 } 29438 }); 29439 })]) 29440 ]), 29441 components: [] 29442 }; 29443 }; 29444 29445 var ResizeTypes; 29446 (function (ResizeTypes) { 29447 ResizeTypes[ResizeTypes['None'] = 0] = 'None'; 29448 ResizeTypes[ResizeTypes['Both'] = 1] = 'Both'; 29449 ResizeTypes[ResizeTypes['Vertical'] = 2] = 'Vertical'; 29450 }(ResizeTypes || (ResizeTypes = {}))); 29451 var getDimensions = function (editor, deltas, resizeType, originalHeight, originalWidth) { 29452 var dimensions = {}; 29453 dimensions.height = calcCappedSize(originalHeight + deltas.top, getMinHeightSetting(editor), getMaxHeightSetting(editor)); 29454 if (resizeType === ResizeTypes.Both) { 29455 dimensions.width = calcCappedSize(originalWidth + deltas.left, getMinWidthSetting(editor), getMaxWidthSetting(editor)); 29456 } 29457 return dimensions; 29458 }; 29459 var resize$3 = function (editor, deltas, resizeType) { 29460 var container = SugarElement.fromDom(editor.getContainer()); 29461 var dimensions = getDimensions(editor, deltas, resizeType, get$7(container), get$8(container)); 29462 each$1(dimensions, function (val, dim) { 29463 return set$2(container, dim, numToPx(val)); 29464 }); 29465 fireResizeEditor(editor); 29466 }; 29467 29468 var getResizeType = function (editor) { 29469 var fallback = !editor.hasPlugin('autoresize'); 29470 var resize = editor.getParam('resize', fallback); 29471 if (resize === false) { 29472 return ResizeTypes.None; 29473 } else if (resize === 'both') { 29474 return ResizeTypes.Both; 29475 } else { 29476 return ResizeTypes.Vertical; 29477 } 29478 }; 29479 var keyboardHandler = function (editor, resizeType, x, y) { 29480 var scale = 20; 29481 var delta = SugarPosition(x * scale, y * scale); 29482 resize$3(editor, delta, resizeType); 29483 return Optional.some(true); 29484 }; 29485 var renderResizeHandler = function (editor, providersBackstage) { 29486 var resizeType = getResizeType(editor); 29487 if (resizeType === ResizeTypes.None) { 29488 return Optional.none(); 29489 } 29490 return Optional.some({ 29491 dom: { 29492 tag: 'div', 29493 classes: ['tox-statusbar__resize-handle'], 29494 attributes: { title: providersBackstage.translate('Resize') }, 29495 innerHtml: get$e('resize-handle', providersBackstage.icons) 29496 }, 29497 behaviours: derive$1([ 29498 Dragging.config({ 29499 mode: 'mouse', 29500 repositionTarget: false, 29501 onDrag: function (_comp, _target, delta) { 29502 return resize$3(editor, delta, resizeType); 29503 }, 29504 blockerClass: 'tox-blocker' 29505 }), 29506 Keying.config({
29507 mode: 'special', 29508 onLeft: function () { 29509 return keyboardHandler(editor, resizeType, -1, 0); 29510 }, 29511 onRight: function () { 29512 return keyboardHandler(editor, resizeType, 1, 0); 29513 }, 29514 onUp: function () { 29515 return keyboardHandler(editor, resizeType, 0, -1); 29516 }, 29517 onDown: function () { 29518 return keyboardHandler(editor, resizeType, 0, 1); 29519 } 29520 }), 29521 Tabstopping.config({}), 29522 Focusing.config({}) 29523 ]) 29524 }); 29525 }; 29526 29527 var renderWordCount = function (editor, providersBackstage) { 29528 var _a; 29529 var replaceCountText = function (comp, count, mode) { 29530 return Replacing.set(comp, [text(providersBackstage.translate([ 29531 '{0} ' + mode, 29532 count[mode] 29533 ]))]); 29534 }; 29535 return Button.sketch({ 29536 dom: { 29537 tag: 'button', 29538 classes: ['tox-statusbar__wordcount'] 29539 }, 29540 components: [], 29541 buttonBehaviours: derive$1([ 29542 DisablingConfigs.button(providersBackstage.isDisabled), 29543 receivingConfig(), 29544 Tabstopping.config({}), 29545 Replacing.config({}), 29546 Representing.config({ 29547 store: { 29548 mode: 'memory', 29549 initialValue: { 29550 mode: 'words', 29551 count: { 29552 words: 0, 29553 characters: 0 29554 } 29555 } 29556 } 29557 }), 29558 config('wordcount-events', [ 29559 runOnExecute(function (comp) { 29560 var currentVal = Representing.getValue(comp); 29561 var newMode = currentVal.mode === 'words' ? 'characters' : 'words'; 29562 Representing.setValue(comp, { 29563 mode: newMode, 29564 count: currentVal.count 29565 }); 29566 replaceCountText(comp, currentVal.count, newMode); 29567 }), 29568 runOnAttached(function (comp) { 29569 editor.on('wordCountUpdate', function (e) { 29570 var mode = Representing.getValue(comp).mode; 29571 Representing.setValue(comp, { 29572 mode: mode, 29573 count: e.wordCount 29574 }); 29575 replaceCountText(comp, e.wordCount, mode); 29576 }); 29577 }) 29578 ]) 29579 ]), 29580 eventOrder: (_a = {}, _a[execute()] = [ 29581 'disabling', 29582 'alloy.base.behaviour', 29583 'wordcount-events' 29584 ], _a) 29585 }); 29586 }; 29587 29588 var renderStatusbar = function (editor, providersBackstage) { 29589 var renderBranding = function () { 29590 var label = global$6.translate([ 29591 'Powered by {0}', 29592 'Tiny' 29593 ]); 29594 var linkHtml = '<a href="https://www.tiny.cloud/?utm_campaign=editor_referral&utm_medium=poweredby&utm_source=tinymce&utm_content=v5" rel="noopener" target="_blank" tabindex="-1" aria-label="' + label + '">' + label + '</a>'; 29595 return { 29596 dom: { 29597 tag: 'span', 29598 classes: ['tox-statusbar__branding'], 29599 innerHtml: linkHtml 29600 } 29601 }; 29602 }; 29603 var getTextComponents = function () { 29604 var components = []; 29605 if (editor.getParam('elementpath', true, 'boolean')) { 29606 components.push(renderElementPath(editor, {}, providersBackstage)); 29607 } 29608 if (editor.hasPlugin('wordcount')) { 29609 components.push(renderWordCount(editor, providersBackstage)); 29610 } 29611 if (editor.getParam('branding', true, 'boolean')) { 29612 components.push(renderBranding()); 29613 } 29614 if (components.length > 0) { 29615 return [{ 29616 dom: { 29617 tag: 'div', 29618 classes: ['tox-statusbar__text-container'] 29619 }, 29620 components: components 29621 }]; 29622 } 29623 return []; 29624 }; 29625 var getComponents = function () { 29626 var components = getTextComponents(); 29627 var resizeHandler = renderResizeHandler(editor, providersBackstage); 29628 return components.concat(resizeHandler.toArray()); 29629 }; 29630 return { 29631 dom: { 29632 tag: 'div', 29633 classes: ['tox-statusbar'] 29634 }, 29635 components: getComponents() 29636 }; 29637 }; 29638 29639 var setup$b = function (editor) { 29640 var _a; 29641 var isInline = editor.inline; 29642 var mode = isInline ? Inline : Iframe; 29643 var header = isStickyToolbar(editor) ? StickyHeader : StaticHeader; 29644 var lazyOuterContainer = Optional.none(); 29645 var platform = detect$3(); 29646 var isIE = platform.browser.isIE(); 29647 var platformClasses = isIE ? ['tox-platform-ie'] : []; 29648 var isTouch = platform.deviceType.isTouch(); 29649 var touchPlatformClass = 'tox-platform-touch'; 29650 var deviceClasses = isTouch ? [touchPlatformClass] : []; 29651 var isToolbarBottom = isToolbarLocationBottom(editor); 29652 var uiContainer = getUiContainer(editor); 29653 var dirAttributes = global$6.isRtl() ? { attributes: { dir: 'rtl' } } : {}; 29654 var verticalDirAttributes = { attributes: (_a = {}, _a[Attribute] = isToolbarBottom ? AttributeValue.BottomToTop : AttributeValue.TopToBottom, _a) }; 29655 var lazyHeader = function () { 29656 return lazyOuterContainer.bind(OuterContainer.getHeader); 29657 };
29658 var isHeaderDocked = function () { 29659 return header.isDocked(lazyHeader); 29660 }; 29661 var resizeUiMothership = function () { 29662 set$2(uiMothership.element, 'width', document.body.clientWidth + 'px'); 29663 }; 29664 var makeSinkDefinition = function () { 29665 var isGridUiContainer = eq$1(body(), uiContainer) && get$5(uiContainer, 'display') === 'grid'; 29666 var sinkSpec = { 29667 dom: __assign({ 29668 tag: 'div', 29669 classes: [ 29670 'tox', 29671 'tox-silver-sink', 29672 'tox-tinymce-aux' 29673 ].concat(platformClasses).concat(deviceClasses) 29674 }, dirAttributes), 29675 behaviours: derive$1([Positioning.config({ 29676 useFixed: function () { 29677 return isHeaderDocked(); 29678 } 29679 })]) 29680 }; 29681 var reactiveWidthSpec = { 29682 dom: { styles: { width: document.body.clientWidth + 'px' } }, 29683 events: derive([run(windowResize(), resizeUiMothership)]) 29684 }; 29685 return deepMerge(sinkSpec, isGridUiContainer ? reactiveWidthSpec : {}); 29686 }; 29687 var sink = build$1(makeSinkDefinition()); 29688 var lazySink = function () { 29689 return Result.value(sink); 29690 }; 29691 var memAnchorBar = record({ 29692 dom: { 29693 tag: 'div', 29694 classes: ['tox-anchorbar'] 29695 } 29696 }); 29697 var lazyAnchorBar = function () { 29698 return lazyOuterContainer.bind(function (container) { 29699 return memAnchorBar.getOpt(container); 29700 }).getOrDie('Could not find a anchor bar element'); 29701 }; 29702 var lazyToolbar = function () { 29703 return lazyOuterContainer.bind(function (container) { 29704 return OuterContainer.getToolbar(container); 29705 }).getOrDie('Could not find more toolbar element'); 29706 }; 29707 var lazyThrobber = function () { 29708 return lazyOuterContainer.bind(function (container) { 29709 return OuterContainer.getThrobber(container); 29710 }).getOrDie('Could not find throbber element'); 29711 }; 29712 var backstage = init$8(sink, editor, lazyAnchorBar); 29713 var partMenubar = OuterContainer.parts.menubar({ 29714 dom: { 29715 tag: 'div', 29716 classes: ['tox-menubar'] 29717 }, 29718 backstage: backstage, 29719 onEscape: function () { 29720 editor.focus(); 29721 } 29722 }); 29723 var toolbarMode = getToolbarMode(editor); 29724 var partToolbar = OuterContainer.parts.toolbar(__assign({ 29725 dom: { 29726 tag: 'div', 29727 classes: ['tox-toolbar'] 29728 }, 29729 getSink: lazySink, 29730 providers: backstage.shared.providers, 29731 onEscape: function () { 29732 editor.focus(); 29733 }, 29734 type: toolbarMode, 29735 lazyToolbar: lazyToolbar, 29736 lazyHeader: function () { 29737 return lazyHeader().getOrDie('Could not find header element'); 29738 } 29739 }, verticalDirAttributes)); 29740 var partMultipleToolbar = OuterContainer.parts['multiple-toolbar']({ 29741 dom: { 29742 tag: 'div', 29743 classes: ['tox-toolbar-overlord'] 29744 }, 29745 providers: backstage.shared.providers, 29746 onEscape: function () { 29747 editor.focus(); 29748 }, 29749 type: toolbarMode 29750 }); 29751 var partSocket = OuterContainer.parts.socket({ 29752 dom: { 29753 tag: 'div', 29754 classes: ['tox-edit-area'] 29755 } 29756 }); 29757 var partSidebar = OuterContainer.parts.sidebar({ 29758 dom: { 29759 tag: 'div', 29760 classes: ['tox-sidebar'] 29761 } 29762 }); 29763 var partThrobber = OuterContainer.parts.throbber({ 29764 dom: { 29765 tag: 'div', 29766 classes: ['tox-throbber'] 29767 }, 29768 backstage: backstage 29769 }); 29770 var sb = editor.getParam('statusbar', true, 'boolean'); 29771 var statusbar = sb && !isInline ? Optional.some(renderStatusbar(editor, backstage.shared.providers)) : Optional.none(); 29772 var socketSidebarContainer = { 29773 dom: { 29774 tag: 'div', 29775 classes: ['tox-sidebar-wrap'] 29776 }, 29777 components: [ 29778 partSocket, 29779 partSidebar 29780 ] 29781 }; 29782 var hasMultipleToolbar = isMultipleToolbars(editor); 29783 var hasToolbar = isToolbarEnabled(editor); 29784 var hasMenubar = isMenubarEnabled(editor); 29785 var getPartToolbar = function () { 29786 if (hasMultipleToolbar) { 29787 return [partMultipleToolbar]; 29788 } else if (hasToolbar) { 29789 return [partToolbar]; 29790 } else { 29791 return []; 29792 } 29793 }; 29794 var partHeader = OuterContainer.parts.header({ 29795 dom: __assign({ 29796 tag: 'div', 29797 classes: ['tox-editor-header'] 29798 }, verticalDirAttributes), 29799 components: flatten([
29800 hasMenubar ? [partMenubar] : [], 29801 getPartToolbar(), 29802 useFixedContainer(editor) ? [] : [memAnchorBar.asSpec()] 29803 ]), 29804 sticky: isStickyToolbar(editor), 29805 editor: editor, 29806 sharedBackstage: backstage.shared 29807 }); 29808 var editorComponents = flatten([ 29809 isToolbarBottom ? [] : [partHeader], 29810 isInline ? [] : [socketSidebarContainer], 29811 isToolbarBottom ? [partHeader] : [] 29812 ]); 29813 var editorContainer = { 29814 dom: { 29815 tag: 'div', 29816 classes: ['tox-editor-container'] 29817 }, 29818 components: editorComponents 29819 }; 29820 var containerComponents = flatten([ 29821 [editorContainer], 29822 isInline ? [] : statusbar.toArray(), 29823 [partThrobber] 29824 ]); 29825 var isHidden = isDistractionFree(editor); 29826 var attributes = __assign(__assign({ role: 'application' }, global$6.isRtl() ? { dir: 'rtl' } : {}), isHidden ? { 'aria-hidden': 'true' } : {}); 29827 var outerContainer = build$1(OuterContainer.sketch({ 29828 dom: { 29829 tag: 'div', 29830 classes: [ 29831 'tox', 29832 'tox-tinymce' 29833 ].concat(isInline ? ['tox-tinymce-inline'] : []).concat(isToolbarBottom ? ['tox-tinymce--toolbar-bottom'] : []).concat(deviceClasses).concat(platformClasses), 29834 styles: __assign({ visibility: 'hidden' }, isHidden ? { 29835 opacity: '0', 29836 border: '0' 29837 } : {}), 29838 attributes: attributes 29839 }, 29840 components: containerComponents, 29841 behaviours: derive$1([ 29842 receivingConfig(), 29843 Disabling.config({ disableClass: 'tox-tinymce--disabled' }), 29844 Keying.config({ 29845 mode: 'cyclic', 29846 selector: '.tox-menubar, .tox-toolbar, .tox-toolbar__primary, .tox-toolbar__overflow--open, .tox-sidebar__overflow--open, .tox-statusbar__path, .tox-statusbar__wordcount, .tox-statusbar__branding a, .tox-statusbar__resize-handle' 29847 }) 29848 ]) 29849 })); 29850 lazyOuterContainer = Optional.some(outerContainer); 29851 editor.shortcuts.add('alt+F9', 'focus menubar', function () { 29852 OuterContainer.focusMenubar(outerContainer); 29853 }); 29854 editor.shortcuts.add('alt+F10', 'focus toolbar', function () { 29855 OuterContainer.focusToolbar(outerContainer); 29856 }); 29857 editor.addCommand('ToggleToolbarDrawer', function () { 29858 OuterContainer.toggleToolbarDrawer(outerContainer); 29859 }); 29860 editor.addQueryStateHandler('ToggleToolbarDrawer', function () { 29861 return OuterContainer.isToolbarDrawerToggled(outerContainer); 29862 }); 29863 var mothership = takeover(outerContainer); 29864 var uiMothership = takeover(sink); 29865 setup$3(editor, mothership, uiMothership); 29866 var getUi = function () { 29867 var channels = { 29868 broadcastAll: uiMothership.broadcast, 29869 broadcastOn: uiMothership.broadcastOn, 29870 register: noop 29871 }; 29872 return { channels: channels }; 29873 }; 29874 var setEditorSize = function () { 29875 var parsedHeight = numToPx(getHeightWithFallback(editor)); 29876 var parsedWidth = numToPx(getWidthWithFallback(editor)); 29877 if (!editor.inline) { 29878 if (isValidValue('div', 'width', parsedWidth)) { 29879 set$2(outerContainer.element, 'width', parsedWidth); 29880 } 29881 if (isValidValue('div', 'height', parsedHeight)) { 29882 set$2(outerContainer.element, 'height', parsedHeight); 29883 } else { 29884 set$2(outerContainer.element, 'height', '200px'); 29885 } 29886 } 29887 return parsedHeight; 29888 }; 29889 var renderUI = function () { 29890 header.setup(editor, backstage.shared, lazyHeader); 29891 setup$8(editor, backstage); 29892 setup$9(editor, lazySink, backstage); 29893 setup$6(editor); 29894 setup$7(editor, lazyThrobber, backstage.shared); 29895 map$2(getToolbarGroups(editor), function (toolbarGroupButtonConfig, name) { 29896 editor.ui.registry.addGroupToolbarButton(name, toolbarGroupButtonConfig); 29897 }); 29898 var _a = editor.ui.registry.getAll(), buttons = _a.buttons, menuItems = _a.menuItems, contextToolbars = _a.contextToolbars, sidebars = _a.sidebars; 29899 var toolbarOpt = getMultipleToolbarsSetting(editor); 29900 var rawUiConfig = { 29901 menuItems: menuItems, 29902 menus: getMenus(editor), 29903 menubar: getMenubar(editor), 29904 toolbar: toolbarOpt.getOrThunk(function () { 29905 return getToolbar(editor); 29906 }), 29907 allowToolbarGroups: toolbarMode === ToolbarMode.floating, 29908 buttons: buttons, 29909 sidebar: sidebars 29910 }; 29911 register$4(editor, contextToolbars, sink, { backstage: backstage }); 29912 setup$a(editor, sink); 29913 var elm = editor.getElement(); 29914 var height = setEditorSize(); 29915 var uiComponents = { 29916 mothership: mothership, 29917 uiMothership: uiMothership, 29918 outerContainer: outerContainer 29919 }; 29920 var args = { 29921 targetNode: elm, 29922 height: height 29923 }; 29924 return mode.render(editor, uiComponents, rawUiConfig, backstage, args
29924); 29925 }; 29926 return { 29927 mothership: mothership, 29928 uiMothership: uiMothership, 29929 backstage: backstage, 29930 renderUI: renderUI, 29931 getUi: getUi 29932 }; 29933 }; 29934 29935 var describedBy = function (describedElement, describeElement) { 29936 var describeId = Optional.from(get$3(describedElement, 'id')).fold(function () { 29937 var id = generate$1('dialog-describe'); 29938 set$1(describeElement, 'id', id); 29939 return id; 29940 }, identity); 29941 set$1(describedElement, 'aria-describedby', describeId); 29942 }; 29943 29944 var labelledBy = function (labelledElement, labelElement) { 29945 var labelId = getOpt(labelledElement, 'id').fold(function () { 29946 var id = generate$1('dialog-label'); 29947 set$1(labelElement, 'id', id); 29948 return id; 29949 }, identity); 29950 set$1(labelledElement, 'aria-labelledby', labelId); 29951 }; 29952 29953 var schema$x = constant([ 29954 strict$1('lazySink'), 29955 option('dragBlockClass'), 29956 defaultedFunction('getBounds', win), 29957 defaulted$1('useTabstopAt', always), 29958 defaulted$1('eventOrder', {}), 29959 field$1('modalBehaviours', [Keying]), 29960 onKeyboardHandler('onExecute'), 29961 onStrictKeyboardHandler('onEscape') 29962 ]); 29963 var basic = { sketch: identity }; 29964 var parts$f = constant([ 29965 optional({ 29966 name: 'draghandle', 29967 overrides: function (detail, spec) { 29968 return { 29969 behaviours: derive$1([Dragging.config({ 29970 mode: 'mouse', 29971 getTarget: function (handle) { 29972 return ancestor$2(handle, '[role="dialog"]').getOr(handle); 29973 }, 29974 blockerClass: detail.dragBlockClass.getOrDie(new Error('The drag blocker class was not specified for a dialog with a drag handle: \n' + JSON.stringify(spec, null, 2)).message), 29975 getBounds: detail.getDragBounds 29976 })]) 29977 }; 29978 } 29979 }), 29980 required({ 29981 schema: [strict$1('dom')], 29982 name: 'title' 29983 }), 29984 required({ 29985 factory: basic, 29986 schema: [strict$1('dom')], 29987 name: 'close' 29988 }), 29989 required({ 29990 factory: basic, 29991 schema: [strict$1('dom')], 29992 name: 'body' 29993 }), 29994 optional({ 29995 factory: basic, 29996 schema: [strict$1('dom')], 29997 name: 'footer' 29998 }), 29999 external$1({ 30000 factory: { 30001 sketch: function (spec, detail) { 30002 return __assign(__assign({}, spec), { 30003 dom: detail.dom, 30004 components: detail.components 30005 }); 30006 } 30007 }, 30008 schema: [ 30009 defaulted$1('dom', { 30010 tag: 'div', 30011 styles: { 30012 position: 'fixed', 30013 left: '0px', 30014 top: '0px', 30015 right: '0px', 30016 bottom: '0px' 30017 } 30018 }), 30019 defaulted$1('components', []) 30020 ], 30021 name: 'blocker' 30022 }) 30023 ]); 30024 30025 var block = function (component, config, state, getBusySpec) { 30026 set$1(component.element, 'aria-busy', true); 30027 var root = config.getRoot(component).getOr(component); 30028 var blockerBehaviours = derive$1([ 30029 Keying.config({ 30030 mode: 'special', 30031 onTab: function () { 30032 return Optional.some(true); 30033 }, 30034 onShiftTab: function () { 30035 return Optional.some(true); 30036 } 30037 }), 30038 Focusing.config({}) 30039 ]); 30040 var blockSpec = getBusySpec(root, blockerBehaviours); 30041 var blocker = root.getSystem().build(blockSpec); 30042 Replacing.append(root, premade$1(blocker)); 30043 if (blocker.hasConfigured(Keying)) { 30044 Keying.focusIn(blocker); 30045 } 30046 if (!state.isBlocked()) { 30047 config.onBlock(component); 30048 } 30049 state.blockWith(function () { 30050 return Replacing.remove(root, blocker); 30051 }); 30052 }; 30053 var unblock = function (component, config, state) { 30054 remove$1(component.element, 'aria-busy'); 30055 if (state.isBlocked()) { 30056 config.onUnblock(component); 30057 } 30058 state.clear(); 30059 }; 30060 30061 var BlockingApis = /*#__PURE__*/Object.freeze({ 30062 __proto__: null, 30063 block: block, 30064 unblock: unblock 30065 }); 30066 30067 var BlockingSchema = [ 30068 defaultedFunction('getRoot', Optional.none), 30069 onHandler('onBlock'), 30070 onHandler('onUnblock') 30071 ]; 30072 30073 var init$f = function () { 30074 var blocker = destroyable(); 30075 var blockWith = function (destroy) { 30076 blocker.set({ destroy: destroy }); 30077 }; 30078 return nu$5({ 30079 readState: blocker.isSet, 30080 blockWith: blockWith, 30081 clear: blocker.clear, 30082 isBlocked: blocker.isSet 30083 }); 30084 }; 30085 30086 var BlockingState = /*#__PURE__*/Object.freeze({ 30087 __proto__: null, 30088 init: init$f 30089 }); 30090 30091 var Blocking = create$1({ 30092 fields: BlockingSchema, 30093 name: 'blocking', 30094 apis: BlockingApis, 30095 state: BlockingState 30096 }); 30097 30098 var factory$i = function (detail, components, spec, externals) { 30099 var _a; 30100 var dialogComp = Cell(Optional.none()); 30101 var showDialog = function (dialog) { 30102 dialogComp.set(Optional.some(dialog)); 30103 var sink = detail.lazySink(dialog).getOrDie(); 30104 var externalBlocker = externals.blocker(); 30105 var blocker = sink.getSystem().build(__assign(__assign({}, externalBlocker), {
30106 components: externalBlocker.components.concat([premade$1(dialog)]), 30107 behaviours: derive$1([ 30108 Focusing.config({}), 30109 config('dialog-blocker-events', [runOnSource(focusin(), function () { 30110 Keying.focusIn(dialog); 30111 })]) 30112 ]) 30113 })); 30114 attach$1(sink, blocker); 30115 Keying.focusIn(dialog); 30116 }; 30117 var hideDialog = function (dialog) { 30118 dialogComp.set(Optional.none()); 30119 parent(dialog.element).each(function (blockerDom) { 30120 dialog.getSystem().getByDom(blockerDom).each(function (blocker) { 30121 detach(blocker); 30122 }); 30123 }); 30124 }; 30125 var getDialogBody = function (dialog) { 30126 return getPartOrDie(dialog, detail, 'body'); 30127 }; 30128 var getDialogFooter = function (dialog) { 30129 return getPartOrDie(dialog, detail, 'footer'); 30130 }; 30131 var setBusy = function (dialog, getBusySpec) { 30132 Blocking.block(dialog, getBusySpec); 30133 }; 30134 var setIdle = function (dialog) { 30135 Blocking.unblock(dialog); 30136 }; 30137 var modalEventsId = generate$1('modal-events'); 30138 var eventOrder = __assign(__assign({}, detail.eventOrder), (_a = {}, _a[attachedToDom()] = [modalEventsId].concat(detail.eventOrder['alloy.system.attached'] || []), _a)); 30139 return { 30140 uid: detail.uid, 30141 dom: detail.dom, 30142 components: components, 30143 apis: { 30144 show: showDialog, 30145 hide: hideDialog, 30146 getBody: getDialogBody, 30147 getFooter: getDialogFooter, 30148 setIdle: setIdle, 30149 setBusy: setBusy 30150 }, 30151 eventOrder: eventOrder, 30152 domModification: { 30153 attributes: { 30154 'role': 'dialog',
30155 'aria-modal': 'true' 30156 } 30157 }, 30158 behaviours: augment(detail.modalBehaviours, [ 30159 Replacing.config({}), 30160 Keying.config({ 30161 mode: 'cyclic', 30162 onEnter: detail.onExecute, 30163 onEscape: detail.onEscape, 30164 useTabstopAt: detail.useTabstopAt 30165 }), 30166 Blocking.config({ getRoot: dialogComp.get }), 30167 config(modalEventsId, [runOnAttached(function (c) { 30168 labelledBy(c.element, getPartOrDie(c, detail, 'title').element); 30169 describedBy(c.element, getPartOrDie(c, detail, 'body').element); 30170 })]) 30171 ]) 30172 }; 30173 }; 30174 var ModalDialog = composite$1({ 30175 name: 'ModalDialog', 30176 configFields: schema$x(), 30177 partFields: parts$f(), 30178 factory: factory$i, 30179 apis: { 30180 show: function (apis, dialog) { 30181 apis.show(dialog); 30182 }, 30183 hide: function (apis, dialog) { 30184 apis.hide(dialog); 30185 }, 30186 getBody: function (apis, dialog) { 30187 return apis.getBody(dialog); 30188 }, 30189 getFooter: function (apis, dialog) { 30190 return apis.getFooter(dialog); 30191 }, 30192 setBusy: function (apis, dialog, getBusySpec) { 30193 apis.setBusy(dialog, getBusySpec); 30194 }, 30195 setIdle: function (apis, dialog) { 30196 apis.setIdle(dialog); 30197 } 30198 } 30199 }); 30200 30201 var dialogToggleMenuItemSchema = objOf([ 30202 strictString('type'), 30203 strictString('name') 30204 ].concat(commonMenuItemFields)); 30205 var dialogToggleMenuItemDataProcessor = boolean; 30206 30207 var baseFooterButtonFields = [ 30208 field('name', 'name', defaultedThunk(function () { 30209 return generate$1('button-name'); 30210 }), string), 30211 optionString('icon'), 30212 defaultedStringEnum('align', 'end', [ 30213 'start', 30214 'end' 30215 ]), 30216 defaultedBoolean('primary', false), 30217 defaultedBoolean('disabled', false) 30218 ]; 30219 var dialogFooterButtonFields = __spreadArrays(baseFooterButtonFields, [strictString('text')]); 30220 var normalFooterButtonFields = __spreadArrays([strictStringEnum('type', [ 30221 'submit', 30222 'cancel', 30223 'custom' 30224 ])], dialogFooterButtonFields); 30225 var menuFooterButtonFields = __spreadArrays([ 30226 strictStringEnum('type', ['menu']), 30227 optionString('text'), 30228 optionString('tooltip'), 30229 optionString('icon'), 30230 strictArrayOf('items', dialogToggleMenuItemSchema) 30231 ], baseFooterButtonFields); 30232 var dialogFooterButtonSchema = choose$1('type', { 30233 submit: normalFooterButtonFields, 30234 cancel: normalFooterButtonFields, 30235 custom: normalFooterButtonFields, 30236 menu: menuFooterButtonFields 30237 }); 30238 30239 var alertBannerFields = [ 30240 strictString('type'), 30241 strictString('text'), 30242 strictStringEnum('level', [ 30243 'info', 30244 'warn', 30245 'error', 30246 'success' 30247 ]), 30248 strictString('icon'), 30249 defaulted$1('url', '') 30250 ]; 30251 var alertBannerSchema = objOf(alertBannerFields); 30252 30253 var createBarFields = function (itemsField) { 30254 return [ 30255 strictString('type'), 30256 itemsField 30257 ]; 30258 }; 30259 30260 var buttonFields = [ 30261 strictString('type'), 30262 strictString('text'), 30263 defaultedBoolean('disabled', false), 30264 defaultedBoolean('primary', false), 30265 field('name', 'name', defaultedThunk(function () { 30266 return generate$1('button-name'); 30267 }), string), 30268 optionString('icon'), 30269 defaultedBoolean('borderless', false) 30270 ]; 30271 var buttonSchema = objOf(buttonFields); 30272 30273 var checkboxFields = [ 30274 strictString('type'), 30275 strictString('name'), 30276 strictString('label'), 30277 defaultedBoolean('disabled', false) 30278 ]; 30279 var checkboxSchema = objOf(checkboxFields); 30280 var checkboxDataProcessor = boolean; 30281 30282 var formComponentFields = [ 30283 strictString('type'), 30284 strictString('name') 30285 ]; 30286 var formComponentWithLabelFields = formComponentFields.concat([optionString('label')]); 30287 30288 var collectionFields = formComponentWithLabelFields.concat([defaulted$1('columns', 'auto')]); 30289 var collectionSchema = objOf(collectionFields); 30290 var collectionDataProcessor = arrOfObj$1([
30291 strictString('value'), 30292 strictString('text'), 30293 strictString('icon') 30294 ]); 30295 30296 var colorInputFields = formComponentWithLabelFields; 30297 var colorInputSchema = objOf(colorInputFields); 30298 var colorInputDataProcessor = string; 30299 30300 var colorPickerFields = formComponentWithLabelFields; 30301 var colorPickerSchema = objOf(colorPickerFields); 30302 var colorPickerDataProcessor = string; 30303 30304 var customEditorFields = formComponentFields.concat([ 30305 defaultedString('tag', 'textarea'), 30306 strictString('scriptId'), 30307 strictString('scriptUrl'), 30308 defaultedPostMsg('settings', undefined) 30309 ]); 30310 var customEditorFieldsOld = formComponentFields.concat([ 30311 defaultedString('tag', 'textarea'), 30312 strictFunction('init') 30313 ]); 30314 var customEditorSchema = valueOf(function (v) { 30315 return asRaw('customeditor.old', objOfOnly(customEditorFieldsOld), v).orThunk(function () { 30316 return asRaw('customeditor.new', objOfOnly(customEditorFields), v); 30317 }); 30318 }); 30319 var customEditorDataProcessor = string; 30320 30321 var dropZoneFields = formComponentWithLabelFields; 30322 var dropZoneSchema = objOf(dropZoneFields); 30323 var dropZoneDataProcessor = arrOfVal(); 30324 30325 var createGridFields = function (itemsField) { 30326 return [ 30327 strictString('type'), 30328 strictNumber('columns'), 30329 itemsField 30330 ]; 30331 }; 30332 30333 var htmlPanelFields = [ 30334 strictString('type'), 30335 strictString('html'), 30336 defaultedStringEnum('presets', 'presentation', [ 30337 'presentation', 30338 'document' 30339 ]) 30340 ]; 30341 var htmlPanelSchema = objOf(htmlPanelFields); 30342 30343 var iframeFields = formComponentWithLabelFields.concat([defaultedBoolean('sandboxed', true)]); 30344 var iframeSchema = objOf(iframeFields); 30345 var iframeDataProcessor = string; 30346 30347 var imageToolsFields = formComponentWithLabelFields.concat([strictOf('currentState', objOf([ 30348 strict$1('blob'), 30349 strictString('url') 30350 ]))]); 30351 var imageToolsSchema = objOf(imageToolsFields); 30352 30353 var inputFields = formComponentWithLabelFields.concat([ 30354 optionString('inputMode'), 30355 optionString('placeholder'), 30356 defaultedBoolean('maximized', false), 30357 defaultedBoolean('disabled', false) 30358 ]); 30359 var inputSchema = objOf(inputFields); 30360 var inputDataProcessor = string; 30361 30362 var createLabelFields = function (itemsField) { 30363 return [ 30364 strictString('type'), 30365 strictString('label'), 30366 itemsField 30367 ]; 30368 }; 30369 30370 var listBoxSingleItemFields = [ 30371 strictString('text'), 30372 strictString('value') 30373 ]; 30374 var listBoxNestedItemFields = [ 30375 strictString('text'), 30376 strictArrayOf('items', thunkOf('items', function () { 30377 return listBoxItemSchema; 30378 })) 30379 ]; 30380 var listBoxItemSchema = oneOf([ 30381 objOf(listBoxSingleItemFields), 30382 objOf(listBoxNestedItemFields) 30383 ]); 30384 var listBoxFields = formComponentWithLabelFields.concat([ 30385 strictArrayOf('items', listBoxItemSchema), 30386 defaultedBoolean('disabled', false) 30387 ]); 30388 var listBoxSchema = objOf(listBoxFields); 30389 var listBoxDataProcessor = string; 30390 30391 var selectBoxFields = formComponentWithLabelFields.concat([ 30392 strictArrayOfObj('items', [ 30393 strictString('text'), 30394 strictString('value') 30395 ]), 30396 defaultedNumber('size', 1), 30397 defaultedBoolean('disabled', false) 30398 ]); 30399 var selectBoxSchema = objOf(selectBoxFields); 30400 var selectBoxDataProcessor = string; 30401 30402 var sizeInputFields = formComponentWithLabelFields.concat([ 30403 defaultedBoolean('constrain', true), 30404 defaultedBoolean('disabled', false) 30405 ]); 30406 var sizeInputSchema = objOf(sizeInputFields); 30407 var sizeInputDataProcessor = objOf([ 30408 strictString('width'), 30409 strictString('height') 30410 ]); 30411 30412 var tableFields = [ 30413 strictString('type'), 30414 strictArrayOf('header', string), 30415 strictArrayOf('cells', arrOf(string)) 30416 ]; 30417 var tableSchema = objOf(tableFields); 30418 30419 var textAreaFields = formComponentWithLabelFields.concat([ 30420 optionString('placeholder'), 30421 defaultedBoolean('maximized', false), 30422 defaultedBoolean('disabled', false) 30423 ]); 30424 var textAreaSchema = objOf(textAreaFields); 30425 var textAreaDataProcessor = string; 30426 30427 var urlInputFields = formComponentWithLabelFields.concat([
30428 defaultedStringEnum('filetype', 'file', [ 30429 'image', 30430 'media', 30431 'file' 30432 ]), 30433 defaulted$1('disabled', false) 30434 ]); 30435 var urlInputSchema = objOf(urlInputFields); 30436 var urlInputDataProcessor = objOf([ 30437 strictString('value'), 30438 defaulted$1('meta', {}) 30439 ]); 30440 30441 var createItemsField = function (name) { 30442 return field('items', 'items', strict(), arrOf(valueOf(function (v) { 30443 return asRaw('Checking item of ' + name, itemSchema$3, v).fold(function (sErr) { 30444 return Result.error(formatError(sErr)); 30445 }, function (passValue) { 30446 return Result.value(passValue); 30447 }); 30448 }))); 30449 }; 30450 var itemSchema$3 = valueThunkOf(function () { 30451 return chooseProcessor('type', { 30452 alertbanner: alertBannerSchema, 30453 bar: objOf(createBarFields(createItemsField('bar'))), 30454 button: buttonSchema, 30455 checkbox: checkboxSchema, 30456 colorinput: colorInputSchema, 30457 colorpicker: colorPickerSchema, 30458 dropzone: dropZoneSchema, 30459 grid: objOf(createGridFields(createItemsField('grid'))), 30460 iframe: iframeSchema, 30461 input: inputSchema, 30462 listbox: listBoxSchema, 30463 selectbox: selectBoxSchema, 30464 sizeinput: sizeInputSchema, 30465 textarea: textAreaSchema, 30466 urlinput: urlInputSchema, 30467 customeditor: customEditorSchema, 30468 htmlpanel: htmlPanelSchema, 30469 imagetools: imageToolsSchema, 30470 collection: collectionSchema, 30471 label: objOf(createLabelFields(createItemsField('label'))), 30472 table: tableSchema, 30473 panel: panelSchema 30474 }); 30475 }); 30476 var panelFields = [ 30477 strictString('type'), 30478 defaulted$1('classes', []), 30479 strictArrayOf('items', itemSchema$3) 30480 ]; 30481 var panelSchema = objOf(panelFields); 30482 30483 var tabFields = [ 30484 field('name', 'name', defaultedThunk(function () { 30485 return generate$1('tab-name'); 30486 }), string), 30487 strictString('title'), 30488 strictArrayOf('items', itemSchema$3) 30489 ]; 30490 var tabPanelFields = [ 30491 strictString('type'), 30492 strictArrayOfObj('tabs', tabFields) 30493 ]; 30494 var tabPanelSchema = objOf(tabPanelFields); 30495 30496 var dialogButtonFields = dialogFooterButtonFields; 30497 var dialogButtonSchema = dialogFooterButtonSchema; 30498 var dialogSchema = objOf([ 30499 strictString('title'), 30500 strictOf('body', chooseProcessor('type', { 30501 panel: panelSchema, 30502 tabpanel: tabPanelSchema 30503 })), 30504 defaultedString('size', 'normal'), 30505 strictArrayOf('buttons', dialogButtonSchema), 30506 defaulted$1('initialData', {}), 30507 defaultedFunction('onAction', noop), 30508 defaultedFunction('onChange', noop), 30509 defaultedFunction('onSubmit', noop), 30510 defaultedFunction('onClose', noop), 30511 defaultedFunction('onCancel', noop), 30512 defaulted$1('onTabChange', noop) 30513 ]); 30514 var createDialog = function (spec) { 30515 return asRaw('dialog', dialogSchema, spec); 30516 }; 30517 30518 var urlDialogButtonSchema = objOf(__spreadArrays([strictStringEnum('type', [ 30519 'cancel', 30520 'custom' 30521 ])], dialogButtonFields)); 30522 var urlDialogSchema = objOf([ 30523 strictString('title'), 30524 strictString('url'), 30525 optionNumber('height'), 30526 optionNumber('width'), 30527 optionArrayOf('buttons', urlDialogButtonSchema), 30528 defaultedFunction('onAction', noop), 30529 defaultedFunction('onCancel', noop), 30530 defaultedFunction('onClose', noop), 30531 defaultedFunction('onMessage', noop) 30532 ]); 30533 var createUrlDialog = function (spec) { 30534 return asRaw('dialog', urlDialogSchema, spec); 30535 }; 30536 30537 var getAllObjects = function (obj) { 30538 if (isObject(obj)) { 30539 return [obj].concat(bind(values(obj), getAllObjects)); 30540 } else if (isArray(obj)) { 30541 return bind(obj, getAllObjects); 30542 } else { 30543 return []; 30544 } 30545 }; 30546 30547 var isNamedItem = function (obj) { 30548 return isString(obj.type) && isString(obj.name); 30549 }; 30550 var dataProcessors = { 30551 checkbox: checkboxDataProcessor, 30552 colorinput: colorInputDataProcessor, 30553 colorpicker: colorPickerDataProcessor, 30554 dropzone: dropZoneDataProcessor, 30555 input: inputDataProcessor, 30556 iframe: iframeDataProcessor, 30557 sizeinput: sizeInputDataProcessor, 30558 selectbox: selectBoxDataProcessor, 30559 listbox: listBoxDataProcessor, 30560 size: sizeInputDataProcessor, 30561 textarea: textAreaDataProcessor, 30562 urlinput: urlInputDataProcessor, 30563 customeditor: customEditorDataProcessor, 30564 collection: collectionDataProcessor, 30565 togglemenuitem: dialogToggleMenuItemDataProcessor 30566 }; 30567 var getDataProcessor = function (item) { 30568 return Optional.from(dataProcessors[item.type]); 30569 }; 30570 var getNamedItems = function (structure) { 30571 return filter(getAllObjects(structure), isNamedItem); 30572 }; 30573 30574 var createDataValidator = function (structure) { 30575 var namedItems = getNamedItems(structure); 30576 var fields = bind(namedItems, function (item) { 30577 return getDataProcessor(item).fold(function () { 30578 return []; 30579 }, function (schema) { 30580 return [strictOf(item.name, schema)]; 30581 }); 30582 }); 30583 return objOf(fields); 30584 }; 30585 30586 var extract$1 = function (structure) { 30587 var internalDialog = getOrDie(createDialog(structure)); 30588 var dataValidator = createDataValidator(structure); 30589 var initialData = structure.initialData; 30590 return { 30591 internalDialog: internalDialog, 30592 dataValidator: dataValidator, 30593 initialData: initialData 30594 }; 30595 }; 30596 var DialogManager = { 30597 open: function (factory, structure) { 30598 var extraction = extract$1(structure); 30599 return factory(extraction.internalDialog, extraction.initialData, extraction.dataValidator); 30600 }, 30601 openUrl: function (factory, structure) { 30602 var internalDialog = getOrDie(createUrlDialog(structure)); 30603 return factory(internalDialog); 30604 }, 30605 redial: function (structure) { 30606 return extract$1(structure); 30607 } 30608 }; 30609 30610 var toValidValues = function (values) { 30611 var errors = []; 30612 var result = {}; 30613 each$1(values, function (value, name) { 30614 value.fold(function () { 30615 errors.push(name); 30616 }, function (v) { 30617 result[name] = v; 30618 }); 30619 }); 30620 return errors.length > 0 ? Result.error(errors) : Result.value(result); 30621 }; 30622 30623 var renderBodyPanel = function (spec, backstage) { 30624 var memForm = record(Form.sketch(function (parts) { 30625 return { 30626 dom: { 30627 tag: 'div', 30628 classes: ['tox-form'].concat(spec.classes) 30629 }, 30630 components: map(spec.items, function (item) { 30631 return interpretInForm(parts, item, backstage); 30632 }) 30633 }; 30634 })); 30635 return { 30636 dom: { 30637 tag: 'div', 30638 classes: ['tox-dialog__body'] 30639 }, 30640 components: [{ 30641 dom: { 30642 tag: 'div', 30643 classes: ['tox-dialog__body-content'] 30644 }, 30645 components: [memForm.asSpec()] 30646 }], 30647 behaviours: derive$1([ 30648 Keying.config({ 30649 mode: 'acyclic', 30650 useTabstopAt: not(isPseudoStop) 30651 }), 30652 ComposingConfigs.memento(memForm), 30653 RepresentingConfigs.memento(memForm, { 30654 postprocess: function (formValue) { 30655 return toValidValues(formValue).fold(function (err) { 30656 console.error(err); 30657 return {}; 30658 }, function (vals) { 30659 return vals; 30660 }); 30661 } 30662 }) 30663 ]) 30664 }; 30665 }; 30666 30667 var factory$j = function (detail, _spec) { 30668 return { 30669 uid: detail.uid, 30670 dom: detail.dom, 30671 components: detail.components, 30672 events: events$7(detail.action), 30673 behaviours: augment(detail.tabButtonBehaviours, [ 30674 Focusing.config({}), 30675 Keying.config({ 30676 mode: 'execution',
30677 useSpace: true, 30678 useEnter: true 30679 }), 30680 Representing.config({ 30681 store: { 30682 mode: 'memory', 30683 initialValue: detail.value 30684 } 30685 }) 30686 ]), 30687 domModification: detail.domModification 30688 }; 30689 }; 30690 var TabButton = single$2({ 30691 name: 'TabButton', 30692 configFields: [ 30693 defaulted$1('uid', undefined), 30694 strict$1('value'), 30695 field('dom', 'dom', mergeWithThunk(function () { 30696 return { 30697 attributes: { 30698 'role': 'tab', 30699 'id': generate$1('aria'), 30700 'aria-selected': 'false' 30701 } 30702 }; 30703 }), anyValue$1()), 30704 option('action'), 30705 defaulted$1('domModification', {}), 30706 field$1('tabButtonBehaviours', [ 30707 Focusing, 30708 Keying, 30709 Representing 30710 ]), 30711 strict$1('view') 30712 ], 30713 factory: factory$j 30714 }); 30715 30716 var schema$y = constant([ 30717 strict$1('tabs'), 30718 strict$1('dom'), 30719 defaulted$1('clickToDismiss', false), 30720 field$1('tabbarBehaviours', [ 30721 Highlighting, 30722 Keying 30723 ]), 30724 markers([ 30725 'tabClass', 30726 'selectedClass' 30727 ]) 30728 ]); 30729 var tabsPart = group({ 30730 factory: TabButton, 30731 name: 'tabs', 30732 unit: 'tab', 30733 overrides: function (barDetail) { 30734 var dismissTab$1 = function (tabbar, button) { 30735 Highlighting.dehighlight(tabbar, button); 30736 emitWith(tabbar, dismissTab(), { 30737 tabbar: tabbar, 30738 button: button 30739 }); 30740 }; 30741 var changeTab$1 = function (tabbar, button) { 30742 Highlighting.highlight(tabbar, button); 30743 emitWith(tabbar, changeTab(), { 30744 tabbar: tabbar, 30745 button: button 30746 }); 30747 }; 30748 return { 30749 action: function (button) { 30750 var tabbar = button.getSystem().getByUid(barDetail.uid).getOrDie(); 30751 var activeButton = Highlighting.isHighlighted(tabbar, button); 30752 var response = function () { 30753 if (activeButton && barDetail.clickToDismiss) { 30754 return dismissTab$1; 30755 } else if (!activeButton) { 30756 return changeTab$1; 30757 } else { 30758 return noop; 30759 } 30760 }(); 30761 response(tabbar, button); 30762 }, 30763 domModification: { classes: [barDetail.markers.tabClass] } 30764 }; 30765 } 30766 }); 30767 var parts$g = constant([tabsPart]); 30768 30769 var factory$k = function (detail, components, _spec, _externals) { 30770 return { 30771 'uid': detail.uid, 30772 'dom': detail.dom, 30773 components: components, 30774 'debug.sketcher': 'Tabbar', 30775 'domModification': { attributes: { role: 'tablist' } }, 30776 'behaviours': augment(detail.tabbarBehaviours, [ 30777 Highlighting.config({ 30778 highlightClass: detail.markers.selectedClass, 30779 itemClass: detail.markers.tabClass, 30780 onHighlight: function (tabbar, tab) { 30781 set$1(tab.element, 'aria-selected', 'true'); 30782 }, 30783 onDehighlight: function (tabbar, tab) { 30784 set$1(tab.element, 'aria-selected', 'false'); 30785 } 30786 }), 30787 Keying.config({ 30788 mode: 'flow', 30789 getInitial: function (tabbar) { 30790 return Highlighting.getHighlighted(tabbar).map(function (tab) { 30791 return tab.element; 30792 }); 30793 }, 30794 selector: '.' + detail.markers.tabClass, 30795 executeOnMove: true 30796 }) 30797 ]) 30798 }; 30799 }; 30800 var Tabbar = composite$1({ 30801 name: 'Tabbar', 30802 configFields: schema$y(), 30803 partFields: parts$g(), 30804 factory: factory$k 30805 }); 30806 30807 var factory$l = function (detail, _spec) { 30808 return { 30809 uid: detail.uid, 30810 dom: detail.dom, 30811 behaviours: augment(detail.tabviewBehaviours, [Replacing.config({})]), 30812 domModification: { attributes: { role: 'tabpanel' } } 30813 }; 30814 }; 30815 var Tabview = single$2({ 30816 name: 'Tabview', 30817 configFields: [field$1('tabviewBehaviours', [Replacing])], 30818 factory: factory$l 30819 }); 30820 30821 var schema$z = constant([ 30822 defaulted$1('selectFirst', true), 30823 onHandler('onChangeTab'), 30824 onHandler('onDismissTab'), 30825 defaulted$1('tabs', []), 30826 field$1('tabSectionBehaviours', []) 30827 ]); 30828 var barPart = required({ 30829 factory: Tabbar, 30830 schema: [
30831 strict$1('dom'), 30832 strictObjOf('markers', [ 30833 strict$1('tabClass'), 30834 strict$1('selectedClass') 30835 ]) 30836 ], 30837 name: 'tabbar', 30838 defaults: function (detail) { 30839 return { tabs: detail.tabs }; 30840 } 30841 }); 30842 var viewPart = required({ 30843 factory: Tabview, 30844 name: 'tabview' 30845 }); 30846 var parts$h = constant([ 30847 barPart, 30848 viewPart 30849 ]); 30850 30851 var factory$m = function (detail, components, _spec, _externals) { 30852 var changeTab$1 = function (button) { 30853 var tabValue = Representing.getValue(button); 30854 getPart(button, detail, 'tabview').each(function (tabview) { 30855 var tabWithValue = find(detail.tabs, function (t) { 30856 return t.value === tabValue; 30857 }); 30858 tabWithValue.each(function (tabData) { 30859 var panel = tabData.view(); 30860 getOpt(button.element, 'id').each(function (id) { 30861 set$1(tabview.element, 'aria-labelledby', id); 30862 }); 30863 Replacing.set(tabview, panel); 30864 detail.onChangeTab(tabview, button, panel); 30865 }); 30866 }); 30867 }; 30868 var changeTabBy = function (section, byPred) { 30869 getPart(section, detail, 'tabbar').each(function (tabbar) { 30870 byPred(tabbar).each(emitExecute); 30871 }); 30872 }; 30873 return { 30874 uid: detail.uid, 30875 dom: detail.dom, 30876 components: components, 30877 behaviours: get$d(detail.tabSectionBehaviours), 30878 events: derive(flatten([ 30879 detail.selectFirst ? [runOnAttached(function (section, _simulatedEvent) { 30880 changeTabBy(section, Highlighting.getFirst); 30881 })] : [], 30882 [ 30883 run(changeTab(), function (section, simulatedEvent) { 30884 var button = simulatedEvent.event.button; 30885 changeTab$1(button); 30886 }), 30887 run(dismissTab(), function (section, simulatedEvent) { 30888 var button = simulatedEvent.event.button; 30889 detail.onDismissTab(section, button); 30890 }) 30891 ] 30892 ])), 30893 apis: { 30894 getViewItems: function (section) { 30895 return getPart(section, detail, 'tabview').map(function (tabview) { 30896 return Replacing.contents(tabview); 30897 }).getOr([]); 30898 }, 30899 showTab: function (section, tabKey) { 30900 var getTabIfNotActive = function (tabbar) { 30901 var candidates = Highlighting.getCandidates(tabbar); 30902 var optTab = find(candidates, function (c) { 30903 return Representing.getValue(c) === tabKey; 30904 }); 30905 return optTab.filter(function (tab) { 30906 return !Highlighting.isHighlighted(tabbar, tab); 30907 }); 30908 }; 30909 changeTabBy(section, getTabIfNotActive); 30910 } 30911 } 30912 }; 30913 }; 30914 var TabSection = composite$1({ 30915 name: 'TabSection', 30916 configFields: schema$z(), 30917 partFields: parts$h(), 30918 factory: factory$m, 30919 apis: { 30920 getViewItems: function (apis, component) { 30921 return apis.getViewItems(component); 30922 }, 30923 showTab: function (apis, component, tabKey) { 30924 apis.showTab(component, tabKey); 30925 } 30926 } 30927 }); 30928 30929 var measureHeights = function (allTabs, tabview, tabviewComp) { 30930 return map(allTabs, function (_tab, i) { 30931 Replacing.set(tabviewComp, allTabs[i].view()); 30932 var rect = tabview.dom.getBoundingClientRect(); 30933 Replacing.set(tabviewComp, []); 30934 return rect.height; 30935 }); 30936 }; 30937 var getMaxHeight = function (heights) { 30938 return head(sort(heights, function (a, b) { 30939 if (a > b) { 30940 return -1; 30941 } else if (a < b) { 30942 return +1; 30943 } else { 30944 return 0; 30945 } 30946 })); 30947 }; 30948 var getMaxTabviewHeight = function (dialog, tabview, tablist) { 30949 var documentElement$1 = documentElement(dialog).dom; 30950 var rootElm = ancestor$2(dialog, '.tox-dialog-wrap').getOr(dialog); 30951 var isFixed = get$5(rootElm, 'position') === 'fixed'; 30952 var maxHeight; 30953 if (isFixed) { 30954 maxHeight = Math.max(documentElement$1.clientHeight, window.innerHeight); 30955 } else { 30956 maxHeight = Math.max(documentElement$1.offsetHeight, documentElement$1.scrollHeight); 30957 } 30958 var tabviewHeight = get$7(tabview); 30959 var isTabListBeside = tabview.dom.offsetLeft >= tablist.dom.offsetLeft + get$8(tablist); 30960 var currentTabHeight = isTabListBeside ? Math.max(get$7(tablist), tabviewHeight) : tabviewHeight; 30961 var dialogTopMargin = parseInt(get$5(dialog, 'margin-top'), 10) || 0; 30962 var dialogBottomMargin = parseInt(get$5(dialog, 'margin-bottom'), 10) || 0; 30963 var dialogHeight = get$7(dialog) + dialogTopMargin + dialogBottomMargin; 30964 var chromeHeight = dialogHeight - currentTabHeight; 30965 return maxHeight - chromeHeight; 30966 }; 30967 var showTab = function (allTabs, comp) { 30968 head(allTabs).each(function (tab) { 30969 return TabSection.showTab(comp, tab.value); 30970 }); 30971 }; 30972 var setTabviewHeight = function (tabview, height) { 30973 set$2(tabview, 'height', height + 'px'); 30974 if (!detect$3().browser.isIE()) { 30975 set$2(tabview, 'flex-basis', height + 'px'); 30976 } else { 30977 remove$6(tabview, 'flex-basis'); 30978 } 30979 }; 30980 var updateTabviewHeight = function (dialogBody, tabview, maxTabHeight) { 30981 ancestor$2(dialogBody, '[role="dialog"]').each(function (dialog) { 30982 descendant$1(dialog, '[role="tablist"]').each(function (tablist) { 30983 maxTabHeight.get().map(function (height) { 30984 set$2(tabview, 'height', '0'); 30985 set$2(tabview, 'flex-basis', '0'); 30986 return Math.min(height, getMaxTabviewHeight(dialog, tabview, tablist)); 30987 }).each(function (height) { 30988 setTabviewHeight(tabview, height); 30989 }); 30990 }); 30991 }); 30992 }; 30993 var getTabview = function (dialog) { 30994 return descendant$1(dialog, '[role="tabpanel"]'); 30995 }; 30996 var setMode = function (allTabs) { 30997 var smartTabHeight = function () { 30998 var maxTabHeight = Cell(Optional.none()); 30999 var extraEvents = [ 31000 runOnAttached(function (comp) { 31001 var dialog = comp.element; 31002 getTabview(dialog).each(function (tabview) { 31003 set$2(tabview, 'visibility', 'hidden'); 31004 comp.getSystem().getByDom(tabview).toOptional().each(function (tabviewComp) { 31005 var heights = measureHeights(allTabs, tabview, tabviewComp); 31006 var maxTabHeightOpt = getMaxHeight(heights); 31007 maxTabHeight.set(maxTabHeightOpt); 31008 }); 31009 updateTabviewHeight(dialog, tabview, maxTabHeight); 31010 remove$6(tabview, 'visibility'); 31011 showTab(allTabs, comp); 31012 global$2.requestAnimationFrame(function () { 31013 updateTabviewHeight(dialog, tabview, maxTabHeight); 31014 }); 31015 }); 31016 }), 31017 run(windowResize(), function (comp) { 31018 var dialog = comp.element; 31019 getTabview(dialog).each(function (tabview) { 31020 updateTabviewHeight(dialog, tabview, maxTabHeight); 31021 }); 31022 }), 31023 run(formResizeEvent, function (comp, _se) { 31024 var dialog = comp.element; 31025 getTabview(dialog).each(function (tabview) { 31026 var oldFocus = active(getRootNode(tabview)); 31027 set$2(tabview, 'visibility', 'hidden'); 31028 var oldHeight = getRaw(tabview, 'height').map(function (h) { 31029 return parseInt(h, 10); 31030 }); 31031 remove$6(tabview, 'height'); 31032 remove$6(tabview, 'flex-basis'); 31033 var newHeight = tabview.dom.getBoundingClientRect().height; 31034 var hasGrown = oldHeight.forall(function (h) { 31035 return newHeight > h; 31036 }); 31037 if (hasGrown) { 31038 maxTabHeight.set(Optional.from(newHeight)); 31039 updateTabviewHeight(dialog, tabview, maxTabHeight); 31040 } else { 31041 oldHeight.each(function (h) { 31042 setTabviewHeight(tabview, h); 31043 }); 31044 } 31045 remove$6(tabview, 'visibility'); 31046 oldFocus.each(focus$1); 31047 }); 31048 }) 31049 ]; 31050 var selectFirst = false;
31051 return { 31052 extraEvents: extraEvents, 31053 selectFirst: selectFirst 31054 }; 31055 }(); 31056 var naiveTabHeight = function () { 31057 var extraEvents = []; 31058 var selectFirst = true; 31059 return { 31060 extraEvents: extraEvents, 31061 selectFirst: selectFirst 31062 }; 31063 }(); 31064 return { 31065 smartTabHeight: smartTabHeight, 31066 naiveTabHeight: naiveTabHeight 31067 }; 31068 }; 31069 31070 var SendDataToSectionChannel = 'send-data-to-section'; 31071 var SendDataToViewChannel = 'send-data-to-view'; 31072 var renderTabPanel = function (spec, backstage) { 31073 var storedValue = Cell({}); 31074 var updateDataWithForm = function (form) { 31075 var formData = Representing.getValue(form); 31076 var validData = toValidValues(formData).getOr({}); 31077 var currentData = storedValue.get(); 31078 var newData = deepMerge(currentData, validData); 31079 storedValue.set(newData); 31080 }; 31081 var setDataOnForm = function (form) { 31082 var tabData = storedValue.get(); 31083 Representing.setValue(form, tabData); 31084 }; 31085 var oldTab = Cell(null); 31086 var allTabs = map(spec.tabs, function (tab) { 31087 return { 31088 value: tab.name, 31089 dom: { 31090 tag: 'div', 31091 classes: ['tox-dialog__body-nav-item'], 31092 innerHtml: backstage.shared.providers.translate(tab.title) 31093 }, 31094 view: function () { 31095 return [Form.sketch(function (parts) { 31096 return { 31097 dom: { 31098 tag: 'div', 31099 classes: ['tox-form'] 31100 }, 31101 components: map(tab.items, function (item) { 31102 return interpretInForm(parts, item, backstage); 31103 }), 31104 formBehaviours: derive$1([ 31105 Keying.config({ 31106 mode: 'acyclic', 31107 useTabstopAt: not(isPseudoStop) 31108 }), 31109 config('TabView.form.events', [ 31110 runOnAttached(setDataOnForm), 31111 runOnDetached(updateDataWithForm) 31112 ]), 31113 Receiving.config({ 31114 channels: wrapAll$1([ 31115 { 31116 key: SendDataToSectionChannel, 31117 value: { onReceive: updateDataWithForm } 31118 }, 31119 { 31120 key: SendDataToViewChannel, 31121 value: { onReceive: setDataOnForm } 31122 } 31123 ]) 31124 }) 31125 ]) 31126 }; 31127 })]; 31128 } 31129 }; 31130 }); 31131 var tabMode = setMode(allTabs).smartTabHeight; 31132 return TabSection.sketch({ 31133 dom: { 31134 tag: 'div', 31135 classes: ['tox-dialog__body'] 31136 }, 31137 onChangeTab: function (section, button, _viewItems) { 31138 var name = Representing.getValue(button); 31139 emitWith(section, formTabChangeEvent, { 31140 name: name, 31141 oldName: oldTab.get() 31142 }); 31143 oldTab.set(name); 31144 }, 31145 tabs: allTabs, 31146 components: [ 31147 TabSection.parts.tabbar({ 31148 dom: { 31149 tag: 'div', 31150 classes: ['tox-dialog__body-nav'] 31151 }, 31152 components: [Tabbar.parts.tabs({})], 31153 markers: { 31154 tabClass: 'tox-tab', 31155 selectedClass: 'tox-dialog__body-nav-item--active' 31156 }, 31157 tabbarBehaviours: derive$1([Tabstopping.config({})]) 31158 }), 31159 TabSection.parts.tabview({ 31160 dom: { 31161 tag: 'div', 31162 classes: ['tox-dialog__body-content'] 31163 } 31164 }) 31165 ], 31166 selectFirst: tabMode.selectFirst, 31167 tabSectionBehaviours: derive$1([ 31168 config('tabpanel', tabMode.extraEvents), 31169 Keying.config({ mode: 'acyclic' }), 31170 Composing.config({ 31171 find: function (comp) { 31172 return head(TabSection.getViewItems(comp)); 31173 } 31174 }), 31175 Representing.config({ 31176 store: { 31177 mode: 'manual', 31178 getValue: function (tsection) { 31179 tsection.getSystem().broadcastOn([SendDataToSectionChannel], {}); 31180 return storedValue.get(); 31181 }, 31182 setValue: function (tsection, value) { 31183 storedValue.set(value); 31184 tsection.getSystem().broadcastOn([SendDataToViewChannel], {}); 31185 } 31186 } 31187 }) 31188 ]) 31189 }); 31190 }; 31191 31192 var dialogChannel = generate$1('update-dialog'); 31193 var titleChannel = generate$1('update-title'); 31194 var bodyChannel = generate$1('update-body'); 31195 var footerChannel = generate$1('update-footer'); 31196 var bodySendMessageChannel = generate$1('body-send-message'); 31197 31198 var renderBody = function (spec, id, backstage, ariaAttrs) { 31199 var renderComponents = function (incoming) { 31200 switch (incoming.body.type) { 31201 case 'tabpanel': { 31202 return [renderTabPanel(incoming.body, backstage)]; 31203 } 31204 default: { 31205 return [renderBodyPanel(incoming.body, backstage)]; 31206 } 31207 } 31208 }; 31209 var updateState = function (_comp, incoming) { 31210 return Optional.some({ 31211 isTabPanel: function () { 31212 return incoming.body.type === 'tabpanel'; 31213 } 31214 }); 31215 }; 31216 var ariaAttributes = { 'aria-live': 'polite' }; 31217 return { 31218 dom: { 31219 tag: 'div', 31220 classes: ['tox-dialog__content-js'], 31221 attributes: __assign(__assign({}, id.map(function (x) { 31222 return { id: x }; 31223 }).getOr({})), ariaAttrs ? ariaAttributes : {}) 31224 }, 31225 components: [], 31226 behaviours: derive$1([ 31227 ComposingConfigs.childAt(0), 31228 Reflecting.config({ 31229 channel: bodyChannel, 31230 updateState: updateState, 31231 renderComponents: renderComponents, 31232 initialData: spec 31233 }) 31234 ]) 31235 }; 31236 }; 31237 var renderInlineBody = function (spec, contentId, backstage, ariaAttrs) { 31238 return renderBody(spec, Optional.some(contentId), backstage, ariaAttrs); 31239 }; 31240 var renderModalBody = function (spec, backstage) { 31241 var bodySpec = renderBody(spec, Optional.none(), backstage, false); 31242 return ModalDialog.parts.body(bodySpec); 31243 }; 31244 var renderIframeBody = function (spec) { 31245 var bodySpec = { 31246 dom: { 31247 tag: 'div', 31248 classes: ['tox-dialog__content-js'] 31249 }, 31250 components: [{ 31251 dom: { 31252 tag: 'div', 31253 classes: ['tox-dialog__body-iframe'] 31254 }, 31255 components: [craft({ 31256 dom: { 31257 tag: 'iframe', 31258 attributes: { src: spec.url } 31259 }, 31260 behaviours: derive$1([ 31261 Tabstopping.config({}), 31262 Focusing.config({}) 31263 ]) 31264 })] 31265 }], 31266 behaviours: derive$1([Keying.config({ 31267 mode: 'acyclic', 31268 useTabstopAt: not(isPseudoStop) 31269 })]) 31270 }; 31271 return ModalDialog.parts.body(bodySpec); 31272 }; 31273 31274 var isTouch = global$8.deviceType.isTouch(); 31275 var hiddenHeader = function (title, close) { 31276 return { 31277 dom: { 31278 tag: 'div', 31279 styles: { display: 'none' }, 31280 classes: ['tox-dialog__header'] 31281 }, 31282 components: [ 31283 title, 31284 close 31285 ] 31286 }; 31287 }; 31288 var pClose = function (onClose, providersBackstage) { 31289 return ModalDialog.parts.close(Button.sketch({ 31290 dom: { 31291 tag: 'button', 31292 classes: [ 31293 'tox-button', 31294 'tox-button--icon', 31295 'tox-button--naked' 31296 ], 31297 attributes: { 31298 'type': 'button', 31299 'aria-label': providersBackstage.translate('Close') 31300 } 31301 }, 31302 action: onClose, 31303 buttonBehaviours: derive$1([Tabstopping.config({})]) 31304 })); 31305 }; 31306 var pUntitled = function () { 31307 return ModalDialog.parts.title({ 31308 dom: { 31309 tag: 'div', 31310 classes: ['tox-dialog__title'], 31311 innerHtml: '', 31312 styles: { display: 'none' } 31313 } 31314 }); 31315 }; 31316 var pBodyMessage = function (message, providersBackstage) { 31317 return ModalDialog.parts.body({ 31318 dom: { 31319 tag: 'div', 31320 classes: ['tox-dialog__body'] 31321 }, 31322 components: [{ 31323 dom: { 31324 tag: 'div', 31325 classes: ['tox-dialog__body-content'] 31326 }, 31327 components: [{ dom: fromHtml$2('<p>' + providersBackstage.translate(message) + '</p>') }] 31328 }] 31329 }); 31330 }; 31331 var pFooter = function (buttons) { 31332 return ModalDialog.parts.footer({ 31333 dom: { 31334 tag: 'div', 31335 classes: ['tox-dialog__footer'] 31336 }, 31337 components: buttons 31338 }); 31339 }; 31340 var pFooterGroup = function (startButtons, endButtons) { 31341 return [ 31342 Container.sketch({ 31343 dom: { 31344 tag: 'div', 31345 classes: ['tox-dialog__footer-start'] 31346 }, 31347 components: startButtons 31348 }), 31349 Container.sketch({ 31350 dom: { 31351 tag: 'div', 31352 classes: ['tox-dialog__footer-end'] 31353 }, 31354 components: endButtons 31355 }) 31356 ]; 31357 }; 31358 var renderDialog = function (spec) { 31359 var _a; 31360 var dialogClass = 'tox-dialog'; 31361 var blockerClass = dialogClass + '-wrap'; 31362 var blockerBackdropClass = blockerClass + '__backdrop'; 31363 var scrollLockClass = dialogClass + '__disable-scroll'; 31364 return ModalDialog.sketch({ 31365 lazySink: spec.lazySink, 31366 onEscape: function (comp) { 31367 spec.onEscape(comp); 31368 return Optional.some(true); 31369 }, 31370 useTabstopAt: function (elem) { 31371 return !isPseudoStop(elem); 31372 }, 31373 dom: { 31374 tag: 'div',
31375 classes: [dialogClass].concat(spec.extraClasses), 31376 styles: __assign({ position: 'relative' }, spec.extraStyles) 31377 }, 31378 components: __spreadArrays([ 31379 spec.header, 31380 spec.body 31381 ], spec.footer.toArray()), 31382 parts: { 31383 blocker: { 31384 dom: fromHtml$2('<div class="' + blockerClass + '"></div>'), 31385 components: [{ 31386 dom: { 31387 tag: 'div', 31388 classes: isTouch ? [ 31389 blockerBackdropClass, 31390 blockerBackdropClass + '--opaque' 31391 ] : [blockerBackdropClass] 31392 } 31393 }] 31394 } 31395 }, 31396 dragBlockClass: blockerClass, 31397 modalBehaviours: derive$1(__spreadArrays([ 31398 Focusing.config({}), 31399 config('dialog-events', spec.dialogEvents.concat([runOnSource(focusin(), function (comp, _se) { 31400 Keying.focusIn(comp); 31401 })])), 31402 config('scroll-lock', [ 31403 runOnAttached(function () { 31404 add$2(body(), scrollLockClass); 31405 }), 31406 runOnDetached(function () { 31407 remove$4(body(), scrollLockClass); 31408 }) 31409 ]) 31410 ], spec.extraBehaviours)), 31411 eventOrder: __assign((_a = {}, _a[execute()] = ['dialog-events'], _a[attachedToDom()] = [ 31412 'scroll-lock', 31413 'dialog-events', 31414 'alloy.base.behaviour' 31415 ], _a[detachedFromDom()] = [ 31416 'alloy.base.behaviour', 31417 'dialog-events', 31418 'scroll-lock' 31419 ], _a), spec.eventOrder) 31420 }); 31421 }; 31422 31423 var renderClose = function (providersBackstage) { 31424 return Button.sketch({ 31425 dom: { 31426 tag: 'button', 31427 classes: [ 31428 'tox-button', 31429 'tox-button--icon', 31430 'tox-button--naked' 31431 ], 31432 attributes: { 31433 'type': 'button', 31434 'aria-label': providersBackstage.translate('Close'), 31435 'title': providersBackstage.translate('Close') 31436 } 31437 }, 31438 components: [{ 31439 dom: { 31440 tag: 'div', 31441 classes: ['tox-icon'], 31442 innerHtml: get$e('close', providersBackstage.icons) 31443 } 31444 }], 31445 action: function (comp) { 31446 emit(comp, formCancelEvent); 31447 } 31448 }); 31449 }; 31450 var renderTitle = function (spec, id, providersBackstage) { 31451 var renderComponents = function (data) { 31452 return [text(providersBackstage.translate(data.title))]; 31453 }; 31454 return { 31455 dom: { 31456 tag: 'div', 31457 classes: ['tox-dialog__title'], 31458 attributes: __assign({}, id.map(function (x) { 31459 return { id: x }; 31460 }).getOr({})) 31461 }, 31462 components: renderComponents(spec), 31463 behaviours: derive$1([Reflecting.config({ 31464 channel: titleChannel, 31465 renderComponents: renderComponents 31466 })]) 31467 }; 31468 }; 31469 var renderDragHandle = function () { 31470 return { dom: fromHtml$2('<div class="tox-dialog__draghandle"></div>') }; 31471 }; 31472 var renderInlineHeader = function (spec, titleId, providersBackstage) { 31473 return Container.sketch({ 31474 dom: fromHtml$2('<div class="tox-dialog__header"></div>'), 31475 components: [ 31476 renderTitle(spec, Optional.some(titleId), providersBackstage), 31477 renderDragHandle(), 31478 renderClose(providersBackstage) 31479 ], 31480 containerBehaviours: derive$1([Dragging.config({ 31481 mode: 'mouse', 31482 blockerClass: 'blocker', 31483 getTarget: function (handle) { 31484 return closest$3(handle, '[role="dialog"]').getOrDie(); 31485 }, 31486 snaps: { 31487 getSnapPoints: function () { 31488 return []; 31489 }, 31490 leftAttr: 'data-drag-left', 31491 topAttr: 'data-drag-top' 31492 } 31493 })]) 31494 }); 31495 }; 31496 var renderModalHeader = function (spec, providersBackstage) { 31497 var pTitle = ModalDialog.parts.title(renderTitle(spec, Optional.none(), providersBackstage)); 31498 var pHandle = ModalDialog.parts.draghandle(renderDragHandle()); 31499 var pClose = ModalDialog.parts.close(renderClose(providersBackstage)); 31500 var components = [pTitle].concat(spec.draggable ? [pHandle] : []).c
31500oncat([pClose]); 31501 return Container.sketch({ 31502 dom: fromHtml$2('<div class="tox-dialog__header"></div>'), 31503 components: components 31504 }); 31505 }; 31506 31507 var getHeader = function (title, backstage) { 31508 return renderModalHeader({ 31509 title: backstage.shared.providers.translate(title), 31510 draggable: backstage.dialog.isDraggableModal() 31511 }, backstage.shared.providers); 31512 }; 31513 var getBusySpec = function (message, bs, providers) { 31514 return { 31515 dom: { 31516 tag: 'div', 31517 classes: ['tox-dialog__busy-spinner'], 31518 attributes: { 'aria-label': providers.translate(message) }, 31519 styles: { 31520 left: '0px', 31521 right: '0px', 31522 bottom: '0px', 31523 top: '0px', 31524 position: 'absolute' 31525 } 31526 }, 31527 behaviours: bs, 31528 components: [{ dom: fromHtml$2('<div class="tox-spinner"><div></div><div></div><div></div></div>') }] 31529 }; 31530 }; 31531 var getEventExtras = function (lazyDialog, providers, extra) { 31532 return { 31533 onClose: function () { 31534 return extra.closeWindow(); 31535 }, 31536 onBlock: function (blockEvent) { 31537 ModalDialog.setBusy(lazyDialog(), function (_comp, bs) { 31538 return getBusySpec(blockEvent.message, bs, providers); 31539 }); 31540 }, 31541 onUnblock: function () { 31542 ModalDialog.setIdle(lazyDialog()); 31543 } 31544 }; 31545 }; 31546 var renderModalDialog = function (spec, initialData, dialogEvents, backstage) { 31547 var _a; 31548 var updateState = function (_comp, incoming) { 31549 return Optional.some(incoming); 31550 }; 31551 return build$1(renderDialog(__assign(__assign({}, spec), { 31552 lazySink: backstage.shared.getSink, 31553 extraBehaviours: __spreadArrays([ 31554 Reflecting.config({ 31555 channel: dialogChannel, 31556 updateState: updateState, 31557 initialData: initialData 31558 }), 31559 RepresentingConfigs.memory({}) 31560 ], spec.extraBehaviours), 31561 onEscape: function (comp) { 31562 emit(comp, formCancelEvent); 31563 }, 31564 dialogEvents: dialogEvents, 31565 eventOrder: (_a = {}, _a[receive()] = [ 31566 Reflecting.name(), 31567 Receiving.name() 31568 ], _a[attachedToDom()] = [ 31569 'scroll-lock', 31570 Reflecting.name(), 31571 'messages', 31572 'dialog-events', 31573 'alloy.base.behaviour' 31574 ], _a[detachedFromDom()] = [ 31575 'alloy.base.behaviour', 31576 'dialog-events', 31577 'messages', 31578 Reflecting.name(), 31579 'scroll-lock' 31580 ], _a) 31581 }))); 31582 }; 31583 var mapMenuButtons = function (buttons) { 31584 var mapItems = function (button) { 31585 var items = map(button.items, function (item) { 31586 var cell = Cell(false); 31587 return __assign(__assign({}, item), { storage: cell }); 31588 }); 31589 return __assign(__assign({}, button), { items: items }); 31590 }; 31591 return map(buttons, function (button) { 31592 if (button.type === 'menu') { 31593 return mapItems(button); 31594 } 31595 return button; 31596 }); 31597 }; 31598 var extractCellsToObject = function (buttons) { 31599 return foldl(buttons, function (acc, button) { 31600 if (button.type === 'menu') { 31601 var menuButton = button; 31602 return foldl(menuButton.items, function (innerAcc, item) { 31603 innerAcc[item.name] = item.storage; 31604 return innerAcc; 31605 }, acc); 31606 } 31607 return acc; 31608 }, {}); 31609 }; 31610 31611 var initCommonEvents = function (fireApiEvent, extras) { 31612 return [ 31613 runWithTarget(focusin(), onFocus$1), 31614 fireApiEvent(formCloseEvent, function (_api, spec) { 31615 extras.onClose(); 31616 spec.onClose(); 31617 }), 31618 fireApiEvent(formCancelEvent, function (api, spec, _event, self) { 31619 spec.onCancel(api); 31620 emit(self, formCloseEvent); 31621 }), 31622 run(formUnblockEvent, function (_c, _se) { 31623 return extras.onUnblock(); 31624 }), 31625 run(formBlockEvent, function (_c, se) { 31626 return extras.onBlock(se.event); 31627 }) 31628 ]; 31629 }; 31630 var initUrlDialog = function (getInstanceApi, extras) { 31631 var fireApiEvent = function (eventName, f) { 31632 return run(eventName, function (c, se) { 31633 withSpec(c, function (spec, _c) { 31634 f(getInstanceApi(), spec, se.event, c); 31635 }); 31636 }); 31637 }; 31638 var withSpec = function (c, f) { 31639 Reflecting.getState(c).get().each(function (currentDialog) { 31640 f(currentDialog, c); 31641 }); 31642 }; 31643 return __spreadArrays(initCommonEvents(fireApiEvent, extras), [fireApiEvent(formActionEvent, function (api, spec, event) { 31644 spec.onAction(api, { name: event.name }); 31645 })]); 31646 }; 31647 var initDialog = function (getInstanceApi, extras, getSink) { 31648 var fireApiEvent = function (eventName, f) { 31649 return run(eventName, function (c, se) { 31650 withSpec(c, function (spec, _c) { 31651 f(getInstanceApi(), spec, se.event, c); 31652 }); 31653 }); 31654 }; 31655 var withSpec = function (c, f) { 31656 Reflecting.getState(c).get().each(function (currentDialogInit) { 31657 f(currentDialogInit.internalDialog, c); 31658 }); 31659 }; 31660 return __spreadArrays(initCommonEvents(fireApiEvent, extras), [ 31661 fireApiEvent(formSubmitEvent, function (api, spec) { 31662 return spec.onSubmit(api); 31663 }), 31664 fireApiEvent(formChangeEvent, function (api, spec, event) { 31665 spec.onChange(api, { name: event.name }); 31666 }), 31667 fireApiEvent(formActionEvent, function (api, spec, event, component) { 31668 var focusIn = function () { 31669 return Keying.focusIn(component); 31670 }; 31671 var isDisabled = function (focused) { 31672 return has$1(focused, 'disabled') || getOpt(focused, 'aria-disabled').exists(function (val) { 31673 return val === 'true'; 31674 }); 31675 }; 31676 var rootNode = getRootNode(component.element); 31677 var current = active(rootNode); 31678 spec.onAction(api, { 31679 name: event.name, 31680 value: event.value 31681 }); 31682 active(rootNode).fold(focusIn, function (focused) { 31683 if (isDisabled(focused)) { 31684 focusIn(); 31685 } else if (current.exists(function (cur) { 31686 return contains$2(focused, cur) && isDisabled(cur); 31687 })) { 31688 focusIn(); 31689 } else { 31690 getSink().toOptional().filter(function (sink) { 31691 return !contains$2(sink.element, focused); 31692 }).each(focusIn); 31693 } 31694 }); 31695 }), 31696 fireApiEvent(formTabChangeEvent, function (api, spec, event) { 31697 spec.onTabChange(api, { 31698 newTabName: event.name, 31699 oldTabName: event.oldName 31700 }); 31701 }), 31702 runOnDetached(function (component) { 31703 var api = getInstanceApi(); 31704 Representing.setValue(component, api.getData()); 31705 }) 31706 ]); 31707 }; 31708 var SilverDialogEvents = { 31709 initUrlDialog: initUrlDialog, 31710 initDialog: initDialog 31711 }; 31712 31713 var makeButton = function (button, backstage) { 31714 return renderFooterButton(button, button.type, backstage); 31715 }; 31716 var lookup$2 = function (compInSystem, footerButtons, buttonName) { 31717 return find(footerButtons, function (button) { 31718 return button.name === buttonName; 31719 }).bind(function (memButton) { 31720 return memButton.memento.getOpt(compInSystem); 31721 }); 31722 }; 31723 var renderComponents = function (_data, state) { 31724 var footerButtons = state.map(function (s) { 31725 return s.footerButtons; 31726 }).getOr([]); 31727 var buttonGroups = partition(footerButtons, function (button) { 31728 return button.align === 'start'; 31729 }); 31730 var makeGroup = function (edge, buttons) { 31731 return Container.sketch({ 31732 dom: { 31733 tag: 'div', 31734 classes: ['tox-dialog__footer-' + edge] 31735 }, 31736 components: map(buttons, function (button) { 31737 return button.memento.asSpec(); 31738 }) 31739 }); 31740 }; 31741 var startButtons = makeGroup('start', buttonGroups.pass); 31742 var endButtons = makeGroup('end', buttonGroups.fail); 31743 return [ 31744 startButtons, 31745 endButtons 31746 ]; 31747 }; 31748 var renderFooter = function (initSpec, backstage) { 31749 var updateState = function (_comp, data) { 31750 var footerButtons = map(data.buttons, function (button) { 31751 var memButton = record(makeButton(button, backstage)); 31752 return { 31753 name: button.name, 31754 align: button.align, 31755 memento: memButton 31756 }; 31757 }); 31758 var lookupByName = function (compInSystem, buttonName) { 31759 return lookup$2(compInSystem, footerButtons, buttonName); 31760 }; 31761 return Optional.some({ 31762 lookupByName: lookupByName, 31763 footerButtons: footerButtons 31764 }); 31765 }; 31766 return {
31767 dom: fromHtml$2('<div class="tox-dialog__footer"></div>'), 31768 components: [], 31769 behaviours: derive$1([Reflecting.config({ 31770 channel: footerChannel, 31771 initialData: initSpec, 31772 updateState: updateState, 31773 renderComponents: renderComponents 31774 })]) 31775 }; 31776 }; 31777 var renderInlineFooter = function (initSpec, backstage) { 31778 return renderFooter(initSpec, backstage); 31779 }; 31780 var renderModalFooter = function (initSpec, backstage) { 31781 return ModalDialog.parts.footer(renderFooter(initSpec, backstage)); 31782 }; 31783 31784 var getCompByName = function (access, name) { 31785 var root = access.getRoot(); 31786 if (root.getSystem().isConnected()) { 31787 var form_1 = Composing.getCurrent(access.getFormWrapper()).getOr(access.getFormWrapper()); 31788 return Form.getField(form_1, name).fold(function () { 31789 var footer = access.getFooter(); 31790 var footerState = Reflecting.getState(footer); 31791 return footerState.get().bind(function (f) { 31792 return f.lookupByName(form_1, name); 31793 }); 31794 }, function (comp) { 31795 return Optional.some(comp); 31796 }); 31797 } else { 31798 return Optional.none(); 31799 } 31800 }; 31801 var validateData = function (access, data) { 31802 var root = access.getRoot(); 31803 return Reflecting.getState(root).get().map(function (dialogState) { 31804 return getOrDie(asRaw('data', dialogState.dataValidator, data)); 31805 }).getOr(data); 31806 }; 31807 var getDialogApi = function (access, doRedial, menuItemStates) { 31808 var withRoot = function (f) { 31809 var root = access.getRoot(); 31810 if (root.getSystem().isConnected()) { 31811 f(root); 31812 } 31813 }; 31814 var getData = function () { 31815 var root = access.getRoot(); 31816 var valueComp = root.getSystem().isConnected() ? access.getFormWrapper() : root; 31817 var representedValues = Representing.getValue(valueComp); 31818 var menuItemCurrentState = map$2(menuItemStates, function (cell) { 31819 return cell.get(); 31820 }); 31821 return __assign(__assign({}, representedValues), menuItemCurrentState); 31822 }; 31823 var setData = function (newData) { 31824 withRoot(function (_) { 31825 var prevData = instanceApi.getData(); 31826 var mergedData = __assign(__assign({}, prevData), newData); 31827 var newInternalData = validateData(access, mergedData); 31828 var form = access.getFormWrapper(); 31829 Representing.setValue(form, newInternalData); 31830 each$1(menuItemStates, function (v, k) { 31831 if (has(mergedData, k)) { 31832 v.set(mergedData[k]); 31833 } 31834 }); 31835 }); 31836 }; 31837 var disable = function (name) { 31838 getCompByName(access, name).each(Disabling.disable); 31839 }; 31840 var enable = function (name) { 31841 getCompByName(access, name).each(Disabling.enable); 31842 }; 31843 var focus = function (name) { 31844 getCompByName(access, name).each(Focusing.focus); 31845 }; 31846 var block = function (message) { 31847 if (!isString(message)) { 31848 throw new Error('The dialogInstanceAPI.block function should be passed a blocking message of type string as an argument'); 31849 } 31850 withRoot(function (root) { 31851 emitWith(root, formBlockEvent, { message: message }); 31852 }); 31853 }; 31854 var unblock = function () { 31855 withRoot(function (root) { 31856 emit(root, formUnblockEvent); 31857 }); 31858 }; 31859 var showTab = function (name) { 31860 withRoot(function (_) { 31861 var body = access.getBody(); 31862 var bodyState = Reflecting.getState(body); 31863 if (bodyState.get().exists(function (b) { 31864 return b.isTabPanel(); 31865 })) { 31866 Composing.getCurrent(body).each(function (tabSection) { 31867 TabSection.showTab(tabSection, name); 31868 }); 31869 } 31870 }); 31871 }; 31872 var redial = function (d) { 31873 withRoot(function (root) { 31874 var dialogInit = doRedial(d); 31875 root.getSystem().broadcastOn([dialogChannel], dialogInit); 31876 root.getSystem().broadcastOn([titleChannel], dialogInit.internalDialog); 31877 root.getSystem().broadcastOn([bodyChannel], dialogInit.internalDialog); 31878 root.getSystem().broadcastOn([footerChannel], dialogInit.internalDialog); 31879 instanceApi.setData(dialogInit.initialData); 31880 }); 31881 }; 31882 var close = function () { 31883 withRoot(function (root) { 31884 emit(root, formCloseEvent); 31885 }); 31886 }; 31887 var instanceApi = { 31888 getData: getData, 31889 setData: setData, 31890 disable: disable, 31891 enable: enable, 31892 focus: focus, 31893 block: block, 31894 unblock: unblock, 31895 showTab: showTab, 31896 redial: redial, 31897 close: close 31898 }; 31899 return instanceApi; 31900 }; 31901 31902 var getDialogSizeClasses = function (size) { 31903 switch (size) { 31904 case 'large': 31905 return ['tox-dialog--width-lg']; 31906 case 'medium': 31907 return ['tox-dialog--width-md']; 31908 default: 31909 return []; 31910 } 31911 }; 31912 var renderDialog$1 = function (dialogInit, extra, backstage) { 31913 var header = getHeader(dialogInit.internalDialog.title, backstage); 31914 var body = renderModalBody({ body: dialogInit.internalDialog.body }, backstage); 31915 var storagedMenuButtons = mapMenuButtons(dialogInit.internalDialog.buttons); 31916 var objOfCells = extractCellsToObject(storagedMenuButtons); 31917 var footer = renderModalFooter({ buttons: storagedMenuButtons }, backstage); 31918 var dialogEvents = SilverDialogEvents.initDialog(function () { 31919 return instanceApi; 31920 }, getEventExtras(function () { 31921 return dialog; 31922 }, backstage.shared.providers, extra), backstage.shared.getSink); 31923 var dialogSize = getDialogSizeClasses(dialogInit.internalDialog.size); 31924 var spec = { 31925 header: header, 31926 body: body, 31927 footer: Optional.some(footer),
31928 extraClasses: dialogSize, 31929 extraBehaviours: [], 31930 extraStyles: {} 31931 }; 31932 var dialog = renderModalDialog(spec, dialogInit, dialogEvents, backstage); 31933 var modalAccess = function () { 31934 var getForm = function () { 31935 var outerForm = ModalDialog.getBody(dialog); 31936 return Composing.getCurrent(outerForm).getOr(outerForm); 31937 }; 31938 return { 31939 getRoot: function () { 31940 return dialog; 31941 }, 31942 getBody: function () { 31943 return ModalDialog.getBody(dialog); 31944 }, 31945 getFooter: function () { 31946 return ModalDialog.getFooter(dialog); 31947 }, 31948 getFormWrapper: getForm 31949 }; 31950 }(); 31951 var instanceApi = getDialogApi(modalAccess, extra.redial, objOfCells); 31952 return { 31953 dialog: dialog, 31954 instanceApi: instanceApi 31955 }; 31956 }; 31957 31958 var renderInlineDialog = function (dialogInit, extra, backstage, ariaAttrs) { 31959 var _a, _b; 31960 var dialogLabelId = generate$1('dialog-label'); 31961 var dialogContentId = generate$1('dialog-content'); 31962 var updateState = function (_comp, incoming) { 31963 return Optional.some(incoming); 31964 }; 31965 var memHeader = record(renderInlineHeader({ 31966 title: dialogInit.internalDialog.title, 31967 draggable: true 31968 }, dialogLabelId, backstage.shared.providers)); 31969 var memBody = record(renderInlineBody({ body: dialogInit.internalDialog.body }, dialogContentId, backstage, ariaAttrs)); 31970 var storagedMenuButtons = mapMenuButtons(dialogInit.internalDialog.buttons); 31971 var objOfCells = extractCellsToObject(storagedMenuButtons); 31972 var memFooter = record(renderInlineFooter({ buttons: storagedMenuButtons }, backstage)); 31973 var dialogEvents = SilverDialogEvents.initDialog(function () { 31974 return instanceApi; 31975 }, { 31976 onBlock: function (event) { 31977 Blocking.block(dialog, function (_comp, bs) { 31978 return getBusySpec(event.message, bs, backstage.shared.providers); 31979 }); 31980 }, 31981 onUnblock: function () { 31982 Blocking.unblock(dialog); 31983 }, 31984 onClose: function () { 31985 return extra.closeWindow(); 31986 } 31987 }, backstage.shared.getSink); 31988 var dialog = build$1({ 31989 dom: { 31990 tag: 'div', 31991 classes: [ 31992 'tox-dialog', 31993 'tox-dialog-inline' 31994 ], 31995 attributes: (_a = { role: 'dialog' }, _a['aria-labelledby'] = dialogLabelId, _a['aria-describedby'] = '' + dialogContentId, _a) 31996 }, 31997 eventOrder: (_b = {}, _b[receive()] = [ 31998 Reflecting.name(), 31999 Receiving.name() 32000 ], _b[execute()] = ['execute-on-form'], _b[attachedToDom()] = [ 32001 'reflecting', 32002 'execute-on-form' 32003 ], _b), 32004 behaviours: derive$1([ 32005 Keying.config({ 32006 mode: 'cyclic', 32007 onEscape: function (c) { 32008 emit(c, formCloseEvent); 32009 return Optional.some(true); 32010 }, 32011 useTabstopAt: function (elem) { 32012 return !isPseudoStop(elem) && (name(elem) !== 'button' || get$3(elem, 'disabled') !== 'disabled'); 32013 } 32014 }), 32015 Reflecting.config({ 32016 channel: dialogChannel, 32017 updateState: updateState, 32018 initialData: dialogInit 32019 }), 32020 Focusing.config({}), 32021 config('execute-on-form', dialogEvents.concat([runOnSource(focusin(), function (comp, _se) { 32022 Keying.focusIn(comp); 32023 })])), 32024 Blocking.config({ 32025 getRoot: function () { 32026 return Optional.some(dialog); 32027 } 32028 }), 32029 Replacing.config({}), 32030 RepresentingConfigs.memory({}) 32031 ]), 32032 components: [ 32033 memHeader.asSpec(), 32034 memBody.asSpec(), 32035 memFooter.asSpec() 32036 ] 32037 }); 32038 var instanceApi = getDialogApi({ 32039 getRoot: function () { 32040 return dialog; 32041 }, 32042 getFooter: function () { 32043 return memFooter.get(dialog); 32044 }, 32045 getBody: function () { 32046 return memBody.get(dialog); 32047 }, 32048 getFormWrapper: function () { 32049 var body = memBody.get(dialog); 32050 return Composing.getCurrent(body).getOr(body); 32051 } 32052 }, extra.redial, objOfCells); 32053 return { 32054 dialog: dialog, 32055 instanceApi: instanceApi 32056 }; 32057 }; 32058 32059 var global$h = tinymce.util.Tools.resolve('tinymce.util.URI'); 32060 32061 var getUrlDialogApi = function (root) { 32062 var withRoot = function (f) { 32063 if (root.getSystem().isConnected()) { 32064 f(root); 32065 } 32066 }; 32067 var block = function (message) { 32068 if (!isString(message)) { 32069 throw new Error('The urlDialogInstanceAPI.block function should be passed a blocking message of type string as an argument'); 32070 } 32071 withRoot(function (root) { 32072 emitWith(root, formBlockEvent, { message: message }); 32073 }); 32074 }; 32075 var unblock = function () { 32076 withRoot(function (root) { 32077 emit(root, formUnblockEvent); 32078 }); 32079 }; 32080 var close = function () { 32081 withRoot(function (root) { 32082 emit(root, formCloseEvent); 32083 }); 32084 }; 32085 var sendMessage = function (data) { 32086 withRoot(function (root) { 32087 root.getSystem().broadcastOn([bodySendMessageChannel], data); 32088 }); 32089 }; 32090 return { 32091 block: block, 32092 unblock: unblock, 32093 close: close, 32094 sendMessage: sendMessage 32095 }; 32096 }; 32097 32098 var SUPPORTED_MESSAGE_ACTIONS = [ 32099 'insertContent', 32100 'setContent', 32101 'execCommand', 32102 'close', 32103 'block', 32104 'unblock' 32105 ]; 32106 var isSupportedMessage = function (data) { 32107 return isObject(data) && SUPPORTED_MESSAGE_ACTIONS.indexOf(data.mceAction) !== -1; 32108 }; 32109 var isCustomMessage = function (data) { 32110 return !isSupportedMessage(data) && isObject(data) && has(data, 'mceAction'); 32111 }; 32112 var handleMessage = function (editor, api, data) { 32113 switch (data.mceAction) { 32114 case 'insertContent': 32115 editor.insertContent(data.content); 32116 break; 32117 case 'setContent': 32118 editor.setContent(data.content); 32119 break; 32120 case 'execCommand': 32121 var ui = isBoolean(data.ui) ? data.ui : false;
32122 editor.execCommand(data.cmd, ui, data.value); 32123 break; 32124 case 'close': 32125 api.close(); 32126 break; 32127 case 'block': 32128 api.block(data.message); 32129 break; 32130 case 'unblock': 32131 api.unblock(); 32132 break; 32133 } 32134 }; 32135 var renderUrlDialog = function (internalDialog, extra, editor, backstage) { 32136 var _a; 32137 var header = getHeader(internalDialog.title, backstage); 32138 var body = renderIframeBody(internalDialog); 32139 var footer = internalDialog.buttons.bind(function (buttons) { 32140 if (buttons.length === 0) { 32141 return Optional.none(); 32142 } else { 32143 return Optional.some(renderModalFooter({ buttons: buttons }, backstage)); 32144 } 32145 }); 32146 var dialogEvents = SilverDialogEvents.initUrlDialog(function () { 32147 return instanceApi; 32148 }, getEventExtras(function () { 32149 return dialog; 32150 }, backstage.shared.providers, extra)); 32151 var styles = __assign(__assign({}, internalDialog.height.fold(function () { 32152 return {}; 32153 }, function (height) { 32154 return { 32155 'height': height + 'px', 32156 'max-height': height + 'px' 32157 }; 32158 })), internalDialog.width.fold(function () { 32159 return {}; 32160 }, function (width) { 32161 return { 32162 'width': width + 'px', 32163 'max-width': width + 'px' 32164 }; 32165 })); 32166 var classes = internalDialog.width.isNone() && internalDialog.height.isNone() ? ['tox-dialog--width-lg'] : []; 32167 var iframeUri = new global$h(internalDialog.url, { base_uri: new global$h(window.location.href) }); 32168 var iframeDomain = iframeUri.protocol + '://' + iframeUri.host + (iframeUri.port ? ':' + iframeUri.port : ''); 32169 var messageHandlerUnbinder = Cell(Optional.none()); 32170 var extraBehaviours = [ 32171 config('messages', [ 32172 runOnAttached(function () { 32173 var unbind = bind$3(SugarElement.fromDom(window), 'message', function (e) { 32174 if (iframeUri.isSameOrigin(new global$h(e.raw.origin))) { 32175 var data = e.raw.data; 32176 if (isSupportedMessage(data)) { 32177 handleMessage(editor, instanceApi, data); 32178 } else if (isCustomMessage(data)) { 32179 internalDialog.onMessage(instanceApi, data); 32180 } 32181 } 32182 }); 32183 messageHandlerUnbinder.set(Optional.some(unbind)); 32184 }), 32185 runOnDetached(function () { 32186 messageHandlerUnbinder.get().each(function (unbinder) { 32187 return unbinder.unbind(); 32188 }); 32189 }) 32190 ]), 32191 Receiving.config({ 32192 channels: (_a = {}, _a[bodySendMessageChannel] = { 32193 onReceive: function (comp, data) { 32194 descendant$1(comp.element, 'iframe').each(function (iframeEle) { 32195 var iframeWin = iframeEle.dom.contentWindow; 32196 iframeWin.postMessage(data, iframeDomain); 32197 }); 32198 } 32199 }, _a) 32200 }) 32201 ]; 32202 var spec = { 32203 header: header, 32204 body: body, 32205 footer: footer, 32206 extraClasses: classes, 32207 extraBehaviours: extraBehaviours, 32208 extraStyles: styles 32209 }; 32210 var dialog = renderModalDialog(spec, internalDialog, dialogEvents, backstage); 32211 var instanceApi = getUrlDialogApi(dialog); 32212 return { 32213 dialog: dialog, 32214 instanceApi: instanceApi 32215 }; 32216 }; 32217 32218 var setup$c = function (extras) { 32219 var sharedBackstage = extras.backstage.shared; 32220 var open = function (message, callback) { 32221 var closeDialog = function () { 32222 ModalDialog.hide(alertDialog); 32223 callback(); 32224 }; 32225 var memFooterClose = record(renderFooterButton({ 32226 name: 'close-alert', 32227 text: 'OK', 32228 primary: true, 32229 align: 'end', 32230 disabled: false, 32231 icon: Optional.none() 32232 }, 'cancel', extras.backstage)); 32233 var titleSpec = pUntitled(); 32234 var closeSpec = pClose(closeDialog, sharedBackstage.providers); 32235 var alertDialog = build$1(renderDialog({ 32236 lazySink: function () { 32237 return sharedBackstage.getSink(); 32238 }, 32239 header: hiddenHeader(titleSpec, closeSpec), 32240 body: pBodyMessage(message, sharedBackstage.providers), 32241 footer: Optional.some(pFooter(pFooterGroup([], [memFooterClose.asSpec()]))), 32242 onEscape: closeDialog,
32243 extraClasses: ['tox-alert-dialog'], 32244 extraBehaviours: [], 32245 extraStyles: {}, 32246 dialogEvents: [run(formCancelEvent, closeDialog)], 32247 eventOrder: {} 32248 })); 32249 ModalDialog.show(alertDialog); 32250 var footerCloseButton = memFooterClose.get(alertDialog); 32251 Focusing.focus(footerCloseButton); 32252 }; 32253 return { open: open }; 32254 }; 32255 32256 var setup$d = function (extras) { 32257 var sharedBackstage = extras.backstage.shared; 32258 var open = function (message, callback) { 32259 var closeDialog = function (state) { 32260 ModalDialog.hide(confirmDialog); 32261 callback(state); 32262 }; 32263 var memFooterYes = record(renderFooterButton({ 32264 name: 'yes', 32265 text: 'Yes', 32266 primary: true, 32267 align: 'end', 32268 disabled: false, 32269 icon: Optional.none() 32270 }, 'submit', extras.backstage)); 32271 var footerNo = renderFooterButton({ 32272 name: 'no', 32273 text: 'No', 32274 primary: false, 32275 align: 'end', 32276 disabled: false, 32277 icon: Optional.none() 32278 }, 'cancel', extras.backstage); 32279 var titleSpec = pUntitled(); 32280 var closeSpec = pClose(function () { 32281 return closeDialog(false); 32282 }, sharedBackstage.providers); 32283 var confirmDialog = build$1(renderDialog({ 32284 lazySink: function () { 32285 return sharedBackstage.getSink(); 32286 }, 32287 header: hiddenHeader(titleSpec, closeSpec), 32288 body: pBodyMessage(message, sharedBackstage.providers), 32289 footer: Optional.some(pFooter(pFooterGroup([], [ 32290 footerNo, 32291 memFooterYes.asSpec() 32292 ]))), 32293 onEscape: function () { 32294 return closeDialog(false); 32295 }, 32296 extraClasses: ['tox-confirm-dialog'], 32297 extraBehaviours: [], 32298 extraStyles: {}, 32299 dialogEvents: [ 32300 run(formCancelEvent, function () { 32301 return closeDialog(false); 32302 }), 32303 run(formSubmitEvent, function () { 32304 return closeDialog(true); 32305 }) 32306 ], 32307 eventOrder: {} 32308 })); 32309 ModalDialog.show(confirmDialog); 32310 var footerYesButton = memFooterYes.get(confirmDialog); 32311 Focusing.focus(footerYesButton); 32312 }; 32313 return { open: open }; 32314 }; 32315 32316 var validateData$1 = function (data, validator) { 32317 return getOrDie(asRaw('data', validator, data)); 32318 }; 32319 var isAlertOrConfirmDialog = function (target) { 32320 return closest$4(target, '.tox-alert-dialog') || closest$4(target, '.tox-confirm-dialog'); 32321 }; 32322 var inlineAdditionalBehaviours = function (editor, isStickyToolbar, isToolbarLocationTop) { 32323 if (isStickyToolbar && isToolbarLocationTop) { 32324 return []; 32325 } else { 32326 return [Docking.config({ 32327 contextual: { 32328 lazyContext: function () { 32329 return Optional.some(box(SugarElement.fromDom(editor.getContentAreaContainer()))); 32330 }, 32331 fadeInClass: 'tox-dialog-dock-fadein', 32332 fadeOutClass: 'tox-dialog-dock-fadeout', 32333 transitionClass: 'tox-dialog-dock-transition' 32334 }, 32335 modes: ['top'] 32336 })]; 32337 } 32338 }; 32339 var setup$e = function (extras) { 32340 var backstage = extras.backstage; 32341 var editor = extras.editor; 32342 var isStickyToolbar$1 = isStickyToolbar(editor); 32343 var alertDialog = setup$c(extras); 32344 var confirmDialog = setup$d(extras); 32345 var open = function (config, params, closeWindow) { 32346 if (params !== undefined && params.inline === 'toolbar') { 32347 return openInlineDialog(config, backstage.shared.anchors.inlineDialog(), closeWindow, params.ariaAttrs); 32348 } else if (params !== undefined && params.inline === 'cursor') { 32349 return openInlineDialog(config, backstage.shared.anchors.cursor(), closeWindow, params.ariaAttrs); 32350 } else { 32351 return openModalDialog(config, closeWindow); 32352 } 32353 }; 32354 var openUrl = function (config, closeWindow) { 32355 return openModalUrlDialog(config, closeWindow); 32356 }; 32357 var openModalUrlDialog = function (config, closeWindow) { 32358 var factory = function (contents) { 32359 var dialog = renderUrlDialog(contents, { 32360 closeWindow: function () { 32361 ModalDialog.hide(dialog.dialog);
32362 closeWindow(dialog.instanceApi); 32363 } 32364 }, editor, backstage); 32365 ModalDialog.show(dialog.dialog); 32366 return dialog.instanceApi; 32367 }; 32368 return DialogManager.openUrl(factory, config); 32369 }; 32370 var openModalDialog = function (config, closeWindow) { 32371 var factory = function (contents, internalInitialData, dataValidator) { 32372 var initialData = internalInitialData; 32373 var dialogInit = { 32374 dataValidator: dataValidator, 32375 initialData: initialData, 32376 internalDialog: contents 32377 }; 32378 var dialog = renderDialog$1(dialogInit, { 32379 redial: DialogManager.redial, 32380 closeWindow: function () { 32381 ModalDialog.hide(dialog.dialog); 32382 closeWindow(dialog.instanceApi); 32383 } 32384 }, backstage); 32385 ModalDialog.show(dialog.dialog); 32386 dialog.instanceApi.setData(initialData); 32387 return dialog.instanceApi; 32388 }; 32389 return DialogManager.open(factory, config); 32390 }; 32391 var openInlineDialog = function (config$1, anchor, closeWindow, ariaAttrs) { 32392 var factory = function (contents, internalInitialData, dataValidator) { 32393 var initialData = validateData$1(internalInitialData, dataValidator); 32394 var inlineDialog = value$3(); 32395 var isToolbarLocationTop = backstage.shared.header.isPositionedAtTop(); 32396 var dialogInit = { 32397 dataValidator: dataValidator, 32398 initialData: initialData, 32399 internalDialog: contents 32400 }; 32401 var refreshDocking = function () { 32402 return inlineDialog.on(function (dialog) { 32403 InlineView.reposition(dialog); 32404 Docking.refresh(dialog); 32405 }); 32406 }; 32407 var dialogUi = renderInlineDialog(dialogInit, { 32408 redial: DialogManager.redial, 32409 closeWindow: function () { 32410 inlineDialog.on(InlineView.hide); 32411 editor.off('ResizeEditor', refreshDocking); 32412 inlineDialog.clear(); 32413 closeWindow(dialogUi.instanceApi); 32414 } 32415 }, backstage, ariaAttrs); 32416 var inlineDialogComp = build$1(InlineView.sketch(__assign(__assign({ 32417 lazySink: backstage.shared.getSink, 32418 dom: { 32419 tag: 'div', 32420 classes: [] 32421 }, 32422 fireDismissalEventInstead: {} 32423 }, isToolbarLocationTop ? {} : { fireRepositionEventInstead: {} }), { 32424 inlineBehaviours: derive$1(__spreadArrays([config('window-manager-inline-events', [run(dismissRequested(), function (_comp, _se) { 32425 emit(dialogUi.dialog, formCancelEvent); 32426 })])], inlineAdditionalBehaviours(editor, isStickyToolbar$1, isToolbarLocationTop))), 32427 isExtraPart: function (_comp, target) { 32428 return isAlertOrConfirmDialog(target); 32429 } 32430 }))); 32431 inlineDialog.set(inlineDialogComp); 32432 InlineView.showWithin(inlineDialogComp, anchor, premade$1(dialogUi.dialog), Optional.some(body())); 32433 if (!isStickyToolbar$1 || !isToolbarLocationTop) { 32434 Docking.refresh(inlineDialogComp); 32435 editor.on('ResizeEditor', refreshDocking); 32436 } 32437 dialogUi.instanceApi.setData(initialData); 32438 Keying.focusIn(dialogUi.dialog); 32439 return dialogUi.instanceApi; 32440 }; 32441 return DialogManager.open(factory, config$1); 32442 }; 32443 var confirm = function (message, callback) { 32444 confirmDialog.open(message, function (state) { 32445 callback(state); 32446 }); 32447 }; 32448 var alert = function (message, callback) { 32449 alertDialog.open(message, function () { 32450 callback(); 32451 }); 32452 }; 32453 var close = function (instanceApi) { 32454 instanceApi.close(); 32455 }; 32456 return { 32457 open: open, 32458 openUrl: openUrl, 32459 alert: alert, 32460 close: close, 32461 confirm: confirm 32462 }; 32463 }; 32464 32465 function Theme () { 32466 global$1.add('silver', function (editor) { 32467 var _a = setup$b(editor), uiMothership = _a.uiMothership, backstage = _a.backstage, renderUI = _a.renderUI, getUi = _a.getUi; 32468 Autocompleter.register(editor, backstage.shared); 32469 var windowMgr = setup$e({ 32470 editor: editor, 32471 backstage: backstage 32472 }); 32473 return { 32474 renderUI: renderUI, 32475 getWindowManagerImpl: constant(windowMgr), 32476 getNotificationManagerImpl: function () { 32477 return NotificationManagerImpl(editor, { backstage: backstage }, uiMothership); 32478 }, 32479 ui: getUi() 32480 }; 32481 }); 32482 } 32483 32484 Theme(); 32485 32486}());
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.