Rev 1042 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 597 | daniel-mar | 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 | * |
||
| 1422 | daniel-mar | 7 | * Version: 5.10.8 (2023-10-19) |
| 597 | daniel-mar | 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 | }; |
||
| 637 | daniel-mar | 24 | var isType$1 = function (type) { |
| 597 | daniel-mar | 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 | }; |
||
| 637 | daniel-mar | 34 | var eq$2 = function (t) { |
| 597 | daniel-mar | 35 | return function (a) { |
| 36 | return t === a; |
||
| 37 | }; |
||
| 38 | }; |
||
| 637 | daniel-mar | 39 | var isString = isType$1('string'); |
| 40 | var isObject = isType$1('object'); |
||
| 41 | var isArray = isType$1('array'); |
||
| 42 | var isNull = eq$2(null); |
||
| 597 | daniel-mar | 43 | var isBoolean = isSimpleType('boolean'); |
| 637 | daniel-mar | 44 | var isUndefined = eq$2(undefined); |
| 597 | daniel-mar | 45 | var isNullable = function (a) { |
| 46 | return a === null || a === undefined; |
||
| 47 | }; |
||
| 48 | var isNonNullable = function (a) { |
||
| 49 | return !isNullable(a); |
||
| 50 | }; |
||
| 51 | var isFunction = isSimpleType('function'); |
||
| 52 | var isNumber = isSimpleType('number'); |
||
| 53 | |||
| 54 | var noop = function () { |
||
| 55 | }; |
||
| 56 | var compose = function (fa, fb) { |
||
| 57 | return function () { |
||
| 58 | var args = []; |
||
| 59 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 60 | args[_i] = arguments[_i]; |
||
| 61 | } |
||
| 62 | return fa(fb.apply(null, args)); |
||
| 63 | }; |
||
| 64 | }; |
||
| 65 | var compose1 = function (fbc, fab) { |
||
| 66 | return function (a) { |
||
| 67 | return fbc(fab(a)); |
||
| 68 | }; |
||
| 69 | }; |
||
| 70 | var constant = function (value) { |
||
| 71 | return function () { |
||
| 72 | return value; |
||
| 73 | }; |
||
| 74 | }; |
||
| 75 | var identity = function (x) { |
||
| 76 | return x; |
||
| 77 | }; |
||
| 637 | daniel-mar | 78 | var tripleEquals = function (a, b) { |
| 79 | return a === b; |
||
| 80 | }; |
||
| 597 | daniel-mar | 81 | function curry(fn) { |
| 82 | var initialArgs = []; |
||
| 83 | for (var _i = 1; _i < arguments.length; _i++) { |
||
| 84 | initialArgs[_i - 1] = arguments[_i]; |
||
| 85 | } |
||
| 86 | return function () { |
||
| 87 | var restArgs = []; |
||
| 88 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 89 | restArgs[_i] = arguments[_i]; |
||
| 90 | } |
||
| 91 | var all = initialArgs.concat(restArgs); |
||
| 92 | return fn.apply(null, all); |
||
| 93 | }; |
||
| 94 | } |
||
| 95 | var not = function (f) { |
||
| 96 | return function (t) { |
||
| 97 | return !f(t); |
||
| 98 | }; |
||
| 99 | }; |
||
| 100 | var die = function (msg) { |
||
| 101 | return function () { |
||
| 102 | throw new Error(msg); |
||
| 103 | }; |
||
| 104 | }; |
||
| 105 | var never = constant(false); |
||
| 106 | var always = constant(true); |
||
| 107 | |||
| 637 | daniel-mar | 108 | var none$2 = function () { |
| 597 | daniel-mar | 109 | return NONE; |
| 110 | }; |
||
| 111 | var NONE = function () { |
||
| 112 | var call = function (thunk) { |
||
| 113 | return thunk(); |
||
| 114 | }; |
||
| 637 | daniel-mar | 115 | var id = identity; |
| 597 | daniel-mar | 116 | var me = { |
| 117 | fold: function (n, _s) { |
||
| 118 | return n(); |
||
| 119 | }, |
||
| 120 | isSome: never, |
||
| 121 | isNone: always, |
||
| 122 | getOr: id, |
||
| 123 | getOrThunk: call, |
||
| 124 | getOrDie: function (msg) { |
||
| 125 | throw new Error(msg || 'error: getOrDie called on none.'); |
||
| 126 | }, |
||
| 127 | getOrNull: constant(null), |
||
| 128 | getOrUndefined: constant(undefined), |
||
| 129 | or: id, |
||
| 130 | orThunk: call, |
||
| 637 | daniel-mar | 131 | map: none$2, |
| 597 | daniel-mar | 132 | each: noop, |
| 637 | daniel-mar | 133 | bind: none$2, |
| 597 | daniel-mar | 134 | exists: never, |
| 135 | forall: always, |
||
| 637 | daniel-mar | 136 | filter: function () { |
| 137 | return none$2(); |
||
| 138 | }, |
||
| 597 | daniel-mar | 139 | toArray: function () { |
| 140 | return []; |
||
| 141 | }, |
||
| 142 | toString: constant('none()') |
||
| 143 | }; |
||
| 144 | return me; |
||
| 145 | }(); |
||
| 146 | var some = function (a) { |
||
| 147 | var constant_a = constant(a); |
||
| 148 | var self = function () { |
||
| 149 | return me; |
||
| 150 | }; |
||
| 151 | var bind = function (f) { |
||
| 152 | return f(a); |
||
| 153 | }; |
||
| 154 | var me = { |
||
| 155 | fold: function (n, s) { |
||
| 156 | return s(a); |
||
| 157 | }, |
||
| 158 | isSome: always, |
||
| 159 | isNone: never, |
||
| 160 | getOr: constant_a, |
||
| 161 | getOrThunk: constant_a, |
||
| 162 | getOrDie: constant_a, |
||
| 163 | getOrNull: constant_a, |
||
| 164 | getOrUndefined: constant_a, |
||
| 165 | or: self, |
||
| 166 | orThunk: self, |
||
| 167 | map: function (f) { |
||
| 168 | return some(f(a)); |
||
| 169 | }, |
||
| 170 | each: function (f) { |
||
| 171 | f(a); |
||
| 172 | }, |
||
| 173 | bind: bind, |
||
| 174 | exists: bind, |
||
| 175 | forall: bind, |
||
| 176 | filter: function (f) { |
||
| 177 | return f(a) ? me : NONE; |
||
| 178 | }, |
||
| 179 | toArray: function () { |
||
| 180 | return [a]; |
||
| 181 | }, |
||
| 182 | toString: function () { |
||
| 183 | return 'some(' + a + ')'; |
||
| 184 | } |
||
| 185 | }; |
||
| 186 | return me; |
||
| 187 | }; |
||
| 637 | daniel-mar | 188 | var from$1 = function (value) { |
| 597 | daniel-mar | 189 | return value === null || value === undefined ? NONE : some(value); |
| 190 | }; |
||
| 191 | var Optional = { |
||
| 192 | some: some, |
||
| 637 | daniel-mar | 193 | none: none$2, |
| 194 | from: from$1 |
||
| 597 | daniel-mar | 195 | }; |
| 196 | |||
| 197 | var nativeSlice = Array.prototype.slice; |
||
| 198 | var nativeIndexOf = Array.prototype.indexOf; |
||
| 199 | var nativePush = Array.prototype.push; |
||
| 200 | var rawIndexOf = function (ts, t) { |
||
| 201 | return nativeIndexOf.call(ts, t); |
||
| 202 | }; |
||
| 637 | daniel-mar | 203 | var contains$2 = function (xs, x) { |
| 597 | daniel-mar | 204 | return rawIndexOf(xs, x) > -1; |
| 205 | }; |
||
| 206 | var exists = function (xs, pred) { |
||
| 207 | for (var i = 0, len = xs.length; i < len; i++) { |
||
| 208 | var x = xs[i]; |
||
| 209 | if (pred(x, i)) { |
||
| 210 | return true; |
||
| 211 | } |
||
| 212 | } |
||
| 213 | return false; |
||
| 214 | }; |
||
| 637 | daniel-mar | 215 | var range$1 = function (num, f) { |
| 597 | daniel-mar | 216 | var r = []; |
| 217 | for (var i = 0; i < num; i++) { |
||
| 218 | r.push(f(i)); |
||
| 219 | } |
||
| 220 | return r; |
||
| 221 | }; |
||
| 637 | daniel-mar | 222 | var map$1 = function (xs, f) { |
| 597 | daniel-mar | 223 | var len = xs.length; |
| 224 | var r = new Array(len); |
||
| 225 | for (var i = 0; i < len; i++) { |
||
| 226 | var x = xs[i]; |
||
| 227 | r[i] = f(x, i); |
||
| 228 | } |
||
| 229 | return r; |
||
| 230 | }; |
||
| 637 | daniel-mar | 231 | var each$2 = function (xs, f) { |
| 597 | daniel-mar | 232 | for (var i = 0, len = xs.length; i < len; i++) { |
| 233 | var x = xs[i]; |
||
| 234 | f(x, i); |
||
| 235 | } |
||
| 236 | }; |
||
| 237 | var eachr = function (xs, f) { |
||
| 238 | for (var i = xs.length - 1; i >= 0; i--) { |
||
| 239 | var x = xs[i]; |
||
| 240 | f(x, i); |
||
| 241 | } |
||
| 242 | }; |
||
| 243 | var partition = function (xs, pred) { |
||
| 244 | var pass = []; |
||
| 245 | var fail = []; |
||
| 246 | for (var i = 0, len = xs.length; i < len; i++) { |
||
| 247 | var x = xs[i]; |
||
| 248 | var arr = pred(x, i) ? pass : fail; |
||
| 249 | arr.push(x); |
||
| 250 | } |
||
| 251 | return { |
||
| 252 | pass: pass, |
||
| 253 | fail: fail |
||
| 254 | }; |
||
| 255 | }; |
||
| 637 | daniel-mar | 256 | var filter$2 = function (xs, pred) { |
| 597 | daniel-mar | 257 | var r = []; |
| 258 | for (var i = 0, len = xs.length; i < len; i++) { |
||
| 259 | var x = xs[i]; |
||
| 260 | if (pred(x, i)) { |
||
| 261 | r.push(x); |
||
| 262 | } |
||
| 263 | } |
||
| 264 | return r; |
||
| 265 | }; |
||
| 266 | var foldr = function (xs, f, acc) { |
||
| 637 | daniel-mar | 267 | eachr(xs, function (x, i) { |
| 268 | acc = f(acc, x, i); |
||
| 597 | daniel-mar | 269 | }); |
| 270 | return acc; |
||
| 271 | }; |
||
| 272 | var foldl = function (xs, f, acc) { |
||
| 637 | daniel-mar | 273 | each$2(xs, function (x, i) { |
| 274 | acc = f(acc, x, i); |
||
| 597 | daniel-mar | 275 | }); |
| 276 | return acc; |
||
| 277 | }; |
||
| 278 | var findUntil = function (xs, pred, until) { |
||
| 279 | for (var i = 0, len = xs.length; i < len; i++) { |
||
| 280 | var x = xs[i]; |
||
| 281 | if (pred(x, i)) { |
||
| 282 | return Optional.some(x); |
||
| 283 | } else if (until(x, i)) { |
||
| 284 | break; |
||
| 285 | } |
||
| 286 | } |
||
| 287 | return Optional.none(); |
||
| 288 | }; |
||
| 637 | daniel-mar | 289 | var find$1 = function (xs, pred) { |
| 597 | daniel-mar | 290 | return findUntil(xs, pred, never); |
| 291 | }; |
||
| 292 | var findIndex = function (xs, pred) { |
||
| 293 | for (var i = 0, len = xs.length; i < len; i++) { |
||
| 294 | var x = xs[i]; |
||
| 295 | if (pred(x, i)) { |
||
| 296 | return Optional.some(i); |
||
| 297 | } |
||
| 298 | } |
||
| 299 | return Optional.none(); |
||
| 300 | }; |
||
| 637 | daniel-mar | 301 | var flatten$1 = function (xs) { |
| 597 | daniel-mar | 302 | var r = []; |
| 303 | for (var i = 0, len = xs.length; i < len; ++i) { |
||
| 304 | if (!isArray(xs[i])) { |
||
| 305 | throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs); |
||
| 306 | } |
||
| 307 | nativePush.apply(r, xs[i]); |
||
| 308 | } |
||
| 309 | return r; |
||
| 310 | }; |
||
| 637 | daniel-mar | 311 | var bind$2 = function (xs, f) { |
| 312 | return flatten$1(map$1(xs, f)); |
||
| 597 | daniel-mar | 313 | }; |
| 314 | var forall = function (xs, pred) { |
||
| 315 | for (var i = 0, len = xs.length; i < len; ++i) { |
||
| 316 | var x = xs[i]; |
||
| 317 | if (pred(x, i) !== true) { |
||
| 318 | return false; |
||
| 319 | } |
||
| 320 | } |
||
| 321 | return true; |
||
| 322 | }; |
||
| 323 | var reverse = function (xs) { |
||
| 324 | var r = nativeSlice.call(xs, 0); |
||
| 325 | r.reverse(); |
||
| 326 | return r; |
||
| 327 | }; |
||
| 328 | var mapToObject = function (xs, f) { |
||
| 329 | var r = {}; |
||
| 330 | for (var i = 0, len = xs.length; i < len; i++) { |
||
| 331 | var x = xs[i]; |
||
| 332 | r[String(x)] = f(x, i); |
||
| 333 | } |
||
| 334 | return r; |
||
| 335 | }; |
||
| 336 | var pure = function (x) { |
||
| 337 | return [x]; |
||
| 338 | }; |
||
| 637 | daniel-mar | 339 | var sort$1 = function (xs, comparator) { |
| 597 | daniel-mar | 340 | var copy = nativeSlice.call(xs, 0); |
| 341 | copy.sort(comparator); |
||
| 342 | return copy; |
||
| 343 | }; |
||
| 637 | daniel-mar | 344 | var get$d = function (xs, i) { |
| 597 | daniel-mar | 345 | return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none(); |
| 346 | }; |
||
| 347 | var head = function (xs) { |
||
| 637 | daniel-mar | 348 | return get$d(xs, 0); |
| 597 | daniel-mar | 349 | }; |
| 637 | daniel-mar | 350 | var last$2 = function (xs) { |
| 351 | return get$d(xs, xs.length - 1); |
||
| 597 | daniel-mar | 352 | }; |
| 353 | var findMap = function (arr, f) { |
||
| 354 | for (var i = 0; i < arr.length; i++) { |
||
| 355 | var r = f(arr[i], i); |
||
| 356 | if (r.isSome()) { |
||
| 357 | return r; |
||
| 358 | } |
||
| 359 | } |
||
| 360 | return Optional.none(); |
||
| 361 | }; |
||
| 362 | |||
| 363 | var __assign = function () { |
||
| 364 | __assign = Object.assign || function __assign(t) { |
||
| 365 | for (var s, i = 1, n = arguments.length; i < n; i++) { |
||
| 366 | s = arguments[i]; |
||
| 367 | for (var p in s) |
||
| 368 | if (Object.prototype.hasOwnProperty.call(s, p)) |
||
| 369 | t[p] = s[p]; |
||
| 370 | } |
||
| 371 | return t; |
||
| 372 | }; |
||
| 373 | return __assign.apply(this, arguments); |
||
| 374 | }; |
||
| 637 | daniel-mar | 375 | function __spreadArray(to, from, pack) { |
| 376 | if (pack || arguments.length === 2) |
||
| 377 | for (var i = 0, l = from.length, ar; i < l; i++) { |
||
| 378 | if (ar || !(i in from)) { |
||
| 379 | if (!ar) |
||
| 380 | ar = Array.prototype.slice.call(from, 0, i); |
||
| 381 | ar[i] = from[i]; |
||
| 382 | } |
||
| 383 | } |
||
| 384 | return to.concat(ar || Array.prototype.slice.call(from)); |
||
| 597 | daniel-mar | 385 | } |
| 386 | |||
| 387 | var cached = function (f) { |
||
| 388 | var called = false; |
||
| 389 | var r; |
||
| 390 | return function () { |
||
| 391 | var args = []; |
||
| 392 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 393 | args[_i] = arguments[_i]; |
||
| 394 | } |
||
| 395 | if (!called) { |
||
| 396 | called = true; |
||
| 397 | r = f.apply(null, args); |
||
| 398 | } |
||
| 399 | return r; |
||
| 400 | }; |
||
| 401 | }; |
||
| 402 | |||
| 403 | var DeviceType = function (os, browser, userAgent, mediaMatch) { |
||
| 404 | var isiPad = os.isiOS() && /ipad/i.test(userAgent) === true; |
||
| 405 | var isiPhone = os.isiOS() && !isiPad; |
||
| 406 | var isMobile = os.isiOS() || os.isAndroid(); |
||
| 407 | var isTouch = isMobile || mediaMatch('(pointer:coarse)'); |
||
| 408 | var isTablet = isiPad || !isiPhone && isMobile && mediaMatch('(min-device-width:768px)'); |
||
| 409 | var isPhone = isiPhone || isMobile && !isTablet; |
||
| 410 | var iOSwebview = browser.isSafari() && os.isiOS() && /safari/i.test(userAgent) === false; |
||
| 411 | var isDesktop = !isPhone && !isTablet && !iOSwebview; |
||
| 412 | return { |
||
| 413 | isiPad: constant(isiPad), |
||
| 414 | isiPhone: constant(isiPhone), |
||
| 415 | isTablet: constant(isTablet), |
||
| 416 | isPhone: constant(isPhone), |
||
| 417 | isTouch: constant(isTouch), |
||
| 418 | isAndroid: os.isAndroid, |
||
| 419 | isiOS: os.isiOS, |
||
| 420 | isWebView: constant(iOSwebview), |
||
| 421 | isDesktop: constant(isDesktop) |
||
| 422 | }; |
||
| 423 | }; |
||
| 424 | |||
| 425 | var firstMatch = function (regexes, s) { |
||
| 426 | for (var i = 0; i < regexes.length; i++) { |
||
| 427 | var x = regexes[i]; |
||
| 428 | if (x.test(s)) { |
||
| 429 | return x; |
||
| 430 | } |
||
| 431 | } |
||
| 432 | return undefined; |
||
| 433 | }; |
||
| 637 | daniel-mar | 434 | var find = function (regexes, agent) { |
| 597 | daniel-mar | 435 | var r = firstMatch(regexes, agent); |
| 436 | if (!r) { |
||
| 437 | return { |
||
| 438 | major: 0, |
||
| 439 | minor: 0 |
||
| 440 | }; |
||
| 441 | } |
||
| 442 | var group = function (i) { |
||
| 443 | return Number(agent.replace(r, '$' + i)); |
||
| 444 | }; |
||
| 637 | daniel-mar | 445 | return nu$2(group(1), group(2)); |
| 597 | daniel-mar | 446 | }; |
| 637 | daniel-mar | 447 | var detect$6 = function (versionRegexes, agent) { |
| 597 | daniel-mar | 448 | var cleanedAgent = String(agent).toLowerCase(); |
| 449 | if (versionRegexes.length === 0) { |
||
| 637 | daniel-mar | 450 | return unknown$2(); |
| 597 | daniel-mar | 451 | } |
| 637 | daniel-mar | 452 | return find(versionRegexes, cleanedAgent); |
| 597 | daniel-mar | 453 | }; |
| 637 | daniel-mar | 454 | var unknown$2 = function () { |
| 455 | return nu$2(0, 0); |
||
| 597 | daniel-mar | 456 | }; |
| 637 | daniel-mar | 457 | var nu$2 = function (major, minor) { |
| 597 | daniel-mar | 458 | return { |
| 459 | major: major, |
||
| 460 | minor: minor |
||
| 461 | }; |
||
| 462 | }; |
||
| 463 | var Version = { |
||
| 637 | daniel-mar | 464 | nu: nu$2, |
| 465 | detect: detect$6, |
||
| 466 | unknown: unknown$2 |
||
| 597 | daniel-mar | 467 | }; |
| 468 | |||
| 637 | daniel-mar | 469 | var detectBrowser$1 = function (browsers, userAgentData) { |
| 470 | return findMap(userAgentData.brands, function (uaBrand) { |
||
| 471 | var lcBrand = uaBrand.brand.toLowerCase(); |
||
| 472 | return find$1(browsers, function (browser) { |
||
| 473 | var _a; |
||
| 474 | return lcBrand === ((_a = browser.brand) === null || _a === void 0 ? void 0 : _a.toLowerCase()); |
||
| 475 | }).map(function (info) { |
||
| 476 | return { |
||
| 477 | current: info.name, |
||
| 478 | version: Version.nu(parseInt(uaBrand.version, 10), 0) |
||
| 479 | }; |
||
| 480 | }); |
||
| 481 | }); |
||
| 482 | }; |
||
| 483 | |||
| 484 | var detect$5 = function (candidates, userAgent) { |
||
| 597 | daniel-mar | 485 | var agent = String(userAgent).toLowerCase(); |
| 637 | daniel-mar | 486 | return find$1(candidates, function (candidate) { |
| 597 | daniel-mar | 487 | return candidate.search(agent); |
| 488 | }); |
||
| 489 | }; |
||
| 490 | var detectBrowser = function (browsers, userAgent) { |
||
| 637 | daniel-mar | 491 | return detect$5(browsers, userAgent).map(function (browser) { |
| 597 | daniel-mar | 492 | var version = Version.detect(browser.versionRegexes, userAgent); |
| 493 | return { |
||
| 494 | current: browser.name, |
||
| 495 | version: version |
||
| 496 | }; |
||
| 497 | }); |
||
| 498 | }; |
||
| 499 | var detectOs = function (oses, userAgent) { |
||
| 637 | daniel-mar | 500 | return detect$5(oses, userAgent).map(function (os) { |
| 597 | daniel-mar | 501 | var version = Version.detect(os.versionRegexes, userAgent); |
| 502 | return { |
||
| 503 | current: os.name, |
||
| 504 | version: version |
||
| 505 | }; |
||
| 506 | }); |
||
| 507 | }; |
||
| 637 | daniel-mar | 508 | |
| 509 | var removeFromStart = function (str, numChars) { |
||
| 510 | return str.substring(numChars); |
||
| 597 | daniel-mar | 511 | }; |
| 512 | |||
| 513 | var checkRange = function (str, substr, start) { |
||
| 514 | return substr === '' || str.length >= substr.length && str.substr(start, start + substr.length) === substr; |
||
| 515 | }; |
||
| 637 | daniel-mar | 516 | var removeLeading = function (str, prefix) { |
| 517 | return startsWith(str, prefix) ? removeFromStart(str, prefix.length) : str; |
||
| 518 | }; |
||
| 597 | daniel-mar | 519 | var contains$1 = function (str, substr) { |
| 520 | return str.indexOf(substr) !== -1; |
||
| 521 | }; |
||
| 522 | var startsWith = function (str, prefix) { |
||
| 523 | return checkRange(str, prefix, 0); |
||
| 524 | }; |
||
| 525 | var endsWith = function (str, suffix) { |
||
| 526 | return checkRange(str, suffix, str.length - suffix.length); |
||
| 527 | }; |
||
| 528 | var blank = function (r) { |
||
| 529 | return function (s) { |
||
| 530 | return s.replace(r, ''); |
||
| 531 | }; |
||
| 532 | }; |
||
| 533 | var trim = blank(/^\s+|\s+$/g); |
||
| 534 | var isNotEmpty = function (s) { |
||
| 535 | return s.length > 0; |
||
| 536 | }; |
||
| 637 | daniel-mar | 537 | var isEmpty$1 = function (s) { |
| 538 | return !isNotEmpty(s); |
||
| 539 | }; |
||
| 679 | daniel-mar | 540 | var toFloat = function (value) { |
| 541 | var num = parseFloat(value); |
||
| 542 | return isNaN(num) ? Optional.none() : Optional.some(num); |
||
| 543 | }; |
||
| 597 | daniel-mar | 544 | |
| 545 | var normalVersionRegex = /.*?version\/\ ?([0-9]+)\.([0-9]+).*/; |
||
| 546 | var checkContains = function (target) { |
||
| 547 | return function (uastring) { |
||
| 548 | return contains$1(uastring, target); |
||
| 549 | }; |
||
| 550 | }; |
||
| 551 | var browsers = [ |
||
| 552 | { |
||
| 553 | name: 'Edge', |
||
| 554 | versionRegexes: [/.*?edge\/ ?([0-9]+)\.([0-9]+)$/], |
||
| 555 | search: function (uastring) { |
||
| 556 | return contains$1(uastring, 'edge/') && contains$1(uastring, 'chrome') && contains$1(uastring, 'safari') && contains$1(uastring, 'applewebkit'); |
||
| 557 | } |
||
| 558 | }, |
||
| 559 | { |
||
| 560 | name: 'Chrome', |
||
| 637 | daniel-mar | 561 | brand: 'Chromium', |
| 597 | daniel-mar | 562 | versionRegexes: [ |
| 563 | /.*?chrome\/([0-9]+)\.([0-9]+).*/, |
||
| 564 | normalVersionRegex |
||
| 565 | ], |
||
| 566 | search: function (uastring) { |
||
| 567 | return contains$1(uastring, 'chrome') && !contains$1(uastring, 'chromeframe'); |
||
| 568 | } |
||
| 569 | }, |
||
| 570 | { |
||
| 571 | name: 'IE', |
||
| 572 | versionRegexes: [ |
||
| 573 | /.*?msie\ ?([0-9]+)\.([0-9]+).*/, |
||
| 574 | /.*?rv:([0-9]+)\.([0-9]+).*/ |
||
| 575 | ], |
||
| 576 | search: function (uastring) { |
||
| 577 | return contains$1(uastring, 'msie') || contains$1(uastring, 'trident'); |
||
| 578 | } |
||
| 579 | }, |
||
| 580 | { |
||
| 581 | name: 'Opera', |
||
| 582 | versionRegexes: [ |
||
| 583 | normalVersionRegex, |
||
| 584 | /.*?opera\/([0-9]+)\.([0-9]+).*/ |
||
| 585 | ], |
||
| 586 | search: checkContains('opera') |
||
| 587 | }, |
||
| 588 | { |
||
| 589 | name: 'Firefox', |
||
| 590 | versionRegexes: [/.*?firefox\/\ ?([0-9]+)\.([0-9]+).*/], |
||
| 591 | search: checkContains('firefox') |
||
| 592 | }, |
||
| 593 | { |
||
| 594 | name: 'Safari', |
||
| 595 | versionRegexes: [ |
||
| 596 | normalVersionRegex, |
||
| 597 | /.*?cpu os ([0-9]+)_([0-9]+).*/ |
||
| 598 | ], |
||
| 599 | search: function (uastring) { |
||
| 600 | return (contains$1(uastring, 'safari') || contains$1(uastring, 'mobile/')) && contains$1(uastring, 'applewebkit'); |
||
| 601 | } |
||
| 602 | } |
||
| 603 | ]; |
||
| 604 | var oses = [ |
||
| 605 | { |
||
| 606 | name: 'Windows', |
||
| 607 | search: checkContains('win'), |
||
| 608 | versionRegexes: [/.*?windows\ nt\ ?([0-9]+)\.([0-9]+).*/] |
||
| 609 | }, |
||
| 610 | { |
||
| 611 | name: 'iOS', |
||
| 612 | search: function (uastring) { |
||
| 613 | return contains$1(uastring, 'iphone') || contains$1(uastring, 'ipad'); |
||
| 614 | }, |
||
| 615 | versionRegexes: [ |
||
| 616 | /.*?version\/\ ?([0-9]+)\.([0-9]+).*/, |
||
| 617 | /.*cpu os ([0-9]+)_([0-9]+).*/, |
||
| 618 | /.*cpu iphone os ([0-9]+)_([0-9]+).*/ |
||
| 619 | ] |
||
| 620 | }, |
||
| 621 | { |
||
| 622 | name: 'Android', |
||
| 623 | search: checkContains('android'), |
||
| 624 | versionRegexes: [/.*?android\ ?([0-9]+)\.([0-9]+).*/] |
||
| 625 | }, |
||
| 626 | { |
||
| 627 | name: 'OSX', |
||
| 628 | search: checkContains('mac os x'), |
||
| 629 | versionRegexes: [/.*?mac\ os\ x\ ?([0-9]+)_([0-9]+).*/] |
||
| 630 | }, |
||
| 631 | { |
||
| 632 | name: 'Linux', |
||
| 633 | search: checkContains('linux'), |
||
| 634 | versionRegexes: [] |
||
| 635 | }, |
||
| 636 | { |
||
| 637 | name: 'Solaris', |
||
| 638 | search: checkContains('sunos'), |
||
| 639 | versionRegexes: [] |
||
| 640 | }, |
||
| 641 | { |
||
| 642 | name: 'FreeBSD', |
||
| 643 | search: checkContains('freebsd'), |
||
| 644 | versionRegexes: [] |
||
| 645 | }, |
||
| 646 | { |
||
| 647 | name: 'ChromeOS', |
||
| 648 | search: checkContains('cros'), |
||
| 649 | versionRegexes: [/.*?chrome\/([0-9]+)\.([0-9]+).*/] |
||
| 650 | } |
||
| 651 | ]; |
||
| 652 | var PlatformInfo = { |
||
| 653 | browsers: constant(browsers), |
||
| 654 | oses: constant(oses) |
||
| 655 | }; |
||
| 656 | |||
| 657 | var edge = 'Edge'; |
||
| 658 | var chrome = 'Chrome'; |
||
| 659 | var ie = 'IE'; |
||
| 660 | var opera = 'Opera'; |
||
| 661 | var firefox = 'Firefox'; |
||
| 662 | var safari = 'Safari'; |
||
| 663 | var unknown$1 = function () { |
||
| 664 | return nu$1({ |
||
| 665 | current: undefined, |
||
| 666 | version: Version.unknown() |
||
| 667 | }); |
||
| 668 | }; |
||
| 669 | var nu$1 = function (info) { |
||
| 670 | var current = info.current; |
||
| 671 | var version = info.version; |
||
| 672 | var isBrowser = function (name) { |
||
| 673 | return function () { |
||
| 674 | return current === name; |
||
| 675 | }; |
||
| 676 | }; |
||
| 677 | return { |
||
| 678 | current: current, |
||
| 679 | version: version, |
||
| 680 | isEdge: isBrowser(edge), |
||
| 681 | isChrome: isBrowser(chrome), |
||
| 682 | isIE: isBrowser(ie), |
||
| 683 | isOpera: isBrowser(opera), |
||
| 684 | isFirefox: isBrowser(firefox), |
||
| 685 | isSafari: isBrowser(safari) |
||
| 686 | }; |
||
| 687 | }; |
||
| 688 | var Browser = { |
||
| 689 | unknown: unknown$1, |
||
| 690 | nu: nu$1, |
||
| 691 | edge: constant(edge), |
||
| 692 | chrome: constant(chrome), |
||
| 693 | ie: constant(ie), |
||
| 694 | opera: constant(opera), |
||
| 695 | firefox: constant(firefox), |
||
| 696 | safari: constant(safari) |
||
| 697 | }; |
||
| 698 | |||
| 699 | var windows = 'Windows'; |
||
| 700 | var ios = 'iOS'; |
||
| 701 | var android = 'Android'; |
||
| 702 | var linux = 'Linux'; |
||
| 703 | var osx = 'OSX'; |
||
| 704 | var solaris = 'Solaris'; |
||
| 705 | var freebsd = 'FreeBSD'; |
||
| 706 | var chromeos = 'ChromeOS'; |
||
| 637 | daniel-mar | 707 | var unknown = function () { |
| 708 | return nu({ |
||
| 597 | daniel-mar | 709 | current: undefined, |
| 710 | version: Version.unknown() |
||
| 711 | }); |
||
| 712 | }; |
||
| 637 | daniel-mar | 713 | var nu = function (info) { |
| 597 | daniel-mar | 714 | var current = info.current; |
| 715 | var version = info.version; |
||
| 716 | var isOS = function (name) { |
||
| 717 | return function () { |
||
| 718 | return current === name; |
||
| 719 | }; |
||
| 720 | }; |
||
| 721 | return { |
||
| 722 | current: current, |
||
| 723 | version: version, |
||
| 724 | isWindows: isOS(windows), |
||
| 725 | isiOS: isOS(ios), |
||
| 726 | isAndroid: isOS(android), |
||
| 727 | isOSX: isOS(osx), |
||
| 728 | isLinux: isOS(linux), |
||
| 729 | isSolaris: isOS(solaris), |
||
| 730 | isFreeBSD: isOS(freebsd), |
||
| 731 | isChromeOS: isOS(chromeos) |
||
| 732 | }; |
||
| 733 | }; |
||
| 734 | var OperatingSystem = { |
||
| 637 | daniel-mar | 735 | unknown: unknown, |
| 736 | nu: nu, |
||
| 597 | daniel-mar | 737 | windows: constant(windows), |
| 738 | ios: constant(ios), |
||
| 739 | android: constant(android), |
||
| 740 | linux: constant(linux), |
||
| 741 | osx: constant(osx), |
||
| 742 | solaris: constant(solaris), |
||
| 743 | freebsd: constant(freebsd), |
||
| 744 | chromeos: constant(chromeos) |
||
| 745 | }; |
||
| 746 | |||
| 637 | daniel-mar | 747 | var detect$4 = function (userAgent, userAgentDataOpt, mediaMatch) { |
| 597 | daniel-mar | 748 | var browsers = PlatformInfo.browsers(); |
| 749 | var oses = PlatformInfo.oses(); |
||
| 637 | daniel-mar | 750 | var browser = userAgentDataOpt.bind(function (userAgentData) { |
| 751 | return detectBrowser$1(browsers, userAgentData); |
||
| 752 | }).orThunk(function () { |
||
| 753 | return detectBrowser(browsers, userAgent); |
||
| 754 | }).fold(Browser.unknown, Browser.nu); |
||
| 755 | var os = detectOs(oses, userAgent).fold(OperatingSystem.unknown, OperatingSystem.nu); |
||
| 597 | daniel-mar | 756 | var deviceType = DeviceType(os, browser, userAgent, mediaMatch); |
| 757 | return { |
||
| 758 | browser: browser, |
||
| 759 | os: os, |
||
| 760 | deviceType: deviceType |
||
| 761 | }; |
||
| 762 | }; |
||
| 637 | daniel-mar | 763 | var PlatformDetection = { detect: detect$4 }; |
| 597 | daniel-mar | 764 | |
| 765 | var mediaMatch = function (query) { |
||
| 766 | return window.matchMedia(query).matches; |
||
| 767 | }; |
||
| 768 | var platform = cached(function () { |
||
| 637 | daniel-mar | 769 | return PlatformDetection.detect(navigator.userAgent, Optional.from(navigator.userAgentData), mediaMatch); |
| 597 | daniel-mar | 770 | }); |
| 771 | var detect$3 = function () { |
||
| 772 | return platform(); |
||
| 773 | }; |
||
| 774 | |||
| 775 | var compareDocumentPosition = function (a, b, match) { |
||
| 776 | return (a.compareDocumentPosition(b) & match) !== 0; |
||
| 777 | }; |
||
| 778 | var documentPositionContainedBy = function (a, b) { |
||
| 779 | return compareDocumentPosition(a, b, Node.DOCUMENT_POSITION_CONTAINED_BY); |
||
| 780 | }; |
||
| 781 | |||
| 782 | var COMMENT = 8; |
||
| 783 | var DOCUMENT = 9; |
||
| 784 | var DOCUMENT_FRAGMENT = 11; |
||
| 785 | var ELEMENT = 1; |
||
| 786 | var TEXT = 3; |
||
| 787 | |||
| 637 | daniel-mar | 788 | var fromHtml$1 = function (html, scope) { |
| 597 | daniel-mar | 789 | var doc = scope || document; |
| 790 | var div = doc.createElement('div'); |
||
| 791 | div.innerHTML = html; |
||
| 792 | if (!div.hasChildNodes() || div.childNodes.length > 1) { |
||
| 793 | console.error('HTML does not have a single root node', html); |
||
| 794 | throw new Error('HTML must have a single root node'); |
||
| 795 | } |
||
| 637 | daniel-mar | 796 | return fromDom$1(div.childNodes[0]); |
| 597 | daniel-mar | 797 | }; |
| 798 | var fromTag = function (tag, scope) { |
||
| 799 | var doc = scope || document; |
||
| 800 | var node = doc.createElement(tag); |
||
| 637 | daniel-mar | 801 | return fromDom$1(node); |
| 597 | daniel-mar | 802 | }; |
| 803 | var fromText = function (text, scope) { |
||
| 804 | var doc = scope || document; |
||
| 805 | var node = doc.createTextNode(text); |
||
| 637 | daniel-mar | 806 | return fromDom$1(node); |
| 597 | daniel-mar | 807 | }; |
| 637 | daniel-mar | 808 | var fromDom$1 = function (node) { |
| 597 | daniel-mar | 809 | if (node === null || node === undefined) { |
| 810 | throw new Error('Node cannot be null or undefined'); |
||
| 811 | } |
||
| 812 | return { dom: node }; |
||
| 813 | }; |
||
| 637 | daniel-mar | 814 | var fromPoint$1 = function (docElm, x, y) { |
| 815 | return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom$1); |
||
| 597 | daniel-mar | 816 | }; |
| 817 | var SugarElement = { |
||
| 637 | daniel-mar | 818 | fromHtml: fromHtml$1, |
| 597 | daniel-mar | 819 | fromTag: fromTag, |
| 820 | fromText: fromText, |
||
| 637 | daniel-mar | 821 | fromDom: fromDom$1, |
| 822 | fromPoint: fromPoint$1 |
||
| 597 | daniel-mar | 823 | }; |
| 824 | |||
| 637 | daniel-mar | 825 | var is$2 = function (element, selector) { |
| 597 | daniel-mar | 826 | var dom = element.dom; |
| 827 | if (dom.nodeType !== ELEMENT) { |
||
| 828 | return false; |
||
| 829 | } else { |
||
| 830 | var elem = dom; |
||
| 831 | if (elem.matches !== undefined) { |
||
| 832 | return elem.matches(selector); |
||
| 833 | } else if (elem.msMatchesSelector !== undefined) { |
||
| 834 | return elem.msMatchesSelector(selector); |
||
| 835 | } else if (elem.webkitMatchesSelector !== undefined) { |
||
| 836 | return elem.webkitMatchesSelector(selector); |
||
| 837 | } else if (elem.mozMatchesSelector !== undefined) { |
||
| 838 | return elem.mozMatchesSelector(selector); |
||
| 839 | } else { |
||
| 840 | throw new Error('Browser lacks native selectors'); |
||
| 841 | } |
||
| 842 | } |
||
| 843 | }; |
||
| 844 | var bypassSelector = function (dom) { |
||
| 845 | return dom.nodeType !== ELEMENT && dom.nodeType !== DOCUMENT && dom.nodeType !== DOCUMENT_FRAGMENT || dom.childElementCount === 0; |
||
| 846 | }; |
||
| 637 | daniel-mar | 847 | var all$1 = function (selector, scope) { |
| 597 | daniel-mar | 848 | var base = scope === undefined ? document : scope.dom; |
| 637 | daniel-mar | 849 | return bypassSelector(base) ? [] : map$1(base.querySelectorAll(selector), SugarElement.fromDom); |
| 597 | daniel-mar | 850 | }; |
| 851 | var one = function (selector, scope) { |
||
| 852 | var base = scope === undefined ? document : scope.dom; |
||
| 853 | return bypassSelector(base) ? Optional.none() : Optional.from(base.querySelector(selector)).map(SugarElement.fromDom); |
||
| 854 | }; |
||
| 855 | |||
| 856 | var eq$1 = function (e1, e2) { |
||
| 857 | return e1.dom === e2.dom; |
||
| 858 | }; |
||
| 859 | var regularContains = function (e1, e2) { |
||
| 860 | var d1 = e1.dom; |
||
| 861 | var d2 = e2.dom; |
||
| 862 | return d1 === d2 ? false : d1.contains(d2); |
||
| 863 | }; |
||
| 864 | var ieContains = function (e1, e2) { |
||
| 865 | return documentPositionContainedBy(e1.dom, e2.dom); |
||
| 866 | }; |
||
| 637 | daniel-mar | 867 | var contains = function (e1, e2) { |
| 597 | daniel-mar | 868 | return detect$3().browser.isIE() ? ieContains(e1, e2) : regularContains(e1, e2); |
| 869 | }; |
||
| 637 | daniel-mar | 870 | var is$1 = is$2; |
| 597 | daniel-mar | 871 | |
| 872 | var keys = Object.keys; |
||
| 873 | var hasOwnProperty = Object.hasOwnProperty; |
||
| 874 | var each$1 = function (obj, f) { |
||
| 875 | var props = keys(obj); |
||
| 876 | for (var k = 0, len = props.length; k < len; k++) { |
||
| 877 | var i = props[k]; |
||
| 878 | var x = obj[i]; |
||
| 879 | f(x, i); |
||
| 880 | } |
||
| 881 | }; |
||
| 637 | daniel-mar | 882 | var map = function (obj, f) { |
| 597 | daniel-mar | 883 | return tupleMap(obj, function (x, i) { |
| 884 | return { |
||
| 885 | k: i, |
||
| 886 | v: f(x, i) |
||
| 887 | }; |
||
| 888 | }); |
||
| 889 | }; |
||
| 890 | var tupleMap = function (obj, f) { |
||
| 891 | var r = {}; |
||
| 892 | each$1(obj, function (x, i) { |
||
| 893 | var tuple = f(x, i); |
||
| 894 | r[tuple.k] = tuple.v; |
||
| 895 | }); |
||
| 896 | return r; |
||
| 897 | }; |
||
| 898 | var objAcc = function (r) { |
||
| 899 | return function (x, i) { |
||
| 900 | r[i] = x; |
||
| 901 | }; |
||
| 902 | }; |
||
| 903 | var internalFilter = function (obj, pred, onTrue, onFalse) { |
||
| 904 | var r = {}; |
||
| 905 | each$1(obj, function (x, i) { |
||
| 906 | (pred(x, i) ? onTrue : onFalse)(x, i); |
||
| 907 | }); |
||
| 908 | return r; |
||
| 909 | }; |
||
| 910 | var filter$1 = function (obj, pred) { |
||
| 911 | var t = {}; |
||
| 912 | internalFilter(obj, pred, objAcc(t), noop); |
||
| 913 | return t; |
||
| 914 | }; |
||
| 915 | var mapToArray = function (obj, f) { |
||
| 916 | var r = []; |
||
| 917 | each$1(obj, function (value, name) { |
||
| 918 | r.push(f(value, name)); |
||
| 919 | }); |
||
| 920 | return r; |
||
| 921 | }; |
||
| 922 | var values = function (obj) { |
||
| 637 | daniel-mar | 923 | return mapToArray(obj, identity); |
| 597 | daniel-mar | 924 | }; |
| 925 | var size = function (obj) { |
||
| 926 | return keys(obj).length; |
||
| 927 | }; |
||
| 637 | daniel-mar | 928 | var get$c = function (obj, key) { |
| 929 | return has$1(obj, key) ? Optional.from(obj[key]) : Optional.none(); |
||
| 597 | daniel-mar | 930 | }; |
| 637 | daniel-mar | 931 | var has$1 = function (obj, key) { |
| 597 | daniel-mar | 932 | return hasOwnProperty.call(obj, key); |
| 933 | }; |
||
| 934 | var hasNonNullableKey = function (obj, key) { |
||
| 637 | daniel-mar | 935 | return has$1(obj, key) && obj[key] !== undefined && obj[key] !== null; |
| 597 | daniel-mar | 936 | }; |
| 937 | var isEmpty = function (r) { |
||
| 938 | for (var x in r) { |
||
| 939 | if (hasOwnProperty.call(r, x)) { |
||
| 940 | return false; |
||
| 941 | } |
||
| 942 | } |
||
| 943 | return true; |
||
| 944 | }; |
||
| 945 | |||
| 946 | var validSectionList = [ |
||
| 947 | 'tfoot', |
||
| 948 | 'thead', |
||
| 949 | 'tbody', |
||
| 950 | 'colgroup' |
||
| 951 | ]; |
||
| 952 | var isValidSection = function (parentName) { |
||
| 637 | daniel-mar | 953 | return contains$2(validSectionList, parentName); |
| 597 | daniel-mar | 954 | }; |
| 955 | var grid = function (rows, columns) { |
||
| 956 | return { |
||
| 957 | rows: rows, |
||
| 958 | columns: columns |
||
| 959 | }; |
||
| 960 | }; |
||
| 961 | var address = function (row, column) { |
||
| 962 | return { |
||
| 963 | row: row, |
||
| 964 | column: column |
||
| 965 | }; |
||
| 966 | }; |
||
| 967 | var detail = function (element, rowspan, colspan) { |
||
| 968 | return { |
||
| 969 | element: element, |
||
| 970 | rowspan: rowspan, |
||
| 971 | colspan: colspan |
||
| 972 | }; |
||
| 973 | }; |
||
| 974 | var detailnew = function (element, rowspan, colspan, isNew) { |
||
| 975 | return { |
||
| 976 | element: element, |
||
| 977 | rowspan: rowspan, |
||
| 978 | colspan: colspan, |
||
| 979 | isNew: isNew |
||
| 980 | }; |
||
| 981 | }; |
||
| 982 | var extended = function (element, rowspan, colspan, row, column, isLocked) { |
||
| 983 | return { |
||
| 984 | element: element, |
||
| 985 | rowspan: rowspan, |
||
| 986 | colspan: colspan, |
||
| 987 | row: row, |
||
| 988 | column: column, |
||
| 989 | isLocked: isLocked |
||
| 990 | }; |
||
| 991 | }; |
||
| 637 | daniel-mar | 992 | var rowdetail = function (element, cells, section) { |
| 597 | daniel-mar | 993 | return { |
| 994 | element: element, |
||
| 995 | cells: cells, |
||
| 996 | section: section |
||
| 997 | }; |
||
| 998 | }; |
||
| 637 | daniel-mar | 999 | var rowdetailnew = function (element, cells, section, isNew) { |
| 1000 | return { |
||
| 1001 | element: element, |
||
| 1002 | cells: cells, |
||
| 1003 | section: section, |
||
| 1004 | isNew: isNew |
||
| 1005 | }; |
||
| 1006 | }; |
||
| 597 | daniel-mar | 1007 | var elementnew = function (element, isNew, isLocked) { |
| 1008 | return { |
||
| 1009 | element: element, |
||
| 1010 | isNew: isNew, |
||
| 1011 | isLocked: isLocked |
||
| 1012 | }; |
||
| 1013 | }; |
||
| 637 | daniel-mar | 1014 | var rowcells = function (element, cells, section, isNew) { |
| 597 | daniel-mar | 1015 | return { |
| 1016 | element: element, |
||
| 1017 | cells: cells, |
||
| 1018 | section: section, |
||
| 1019 | isNew: isNew |
||
| 1020 | }; |
||
| 1021 | }; |
||
| 1022 | var bounds = function (startRow, startCol, finishRow, finishCol) { |
||
| 1023 | return { |
||
| 1024 | startRow: startRow, |
||
| 1025 | startCol: startCol, |
||
| 1026 | finishRow: finishRow, |
||
| 1027 | finishCol: finishCol |
||
| 1028 | }; |
||
| 1029 | }; |
||
| 1030 | var columnext = function (element, colspan, column) { |
||
| 1031 | return { |
||
| 1032 | element: element, |
||
| 1033 | colspan: colspan, |
||
| 1034 | column: column |
||
| 1035 | }; |
||
| 1036 | }; |
||
| 637 | daniel-mar | 1037 | var colgroup = function (element, columns) { |
| 1038 | return { |
||
| 1039 | element: element, |
||
| 1040 | columns: columns |
||
| 1041 | }; |
||
| 1042 | }; |
||
| 597 | daniel-mar | 1043 | |
| 637 | daniel-mar | 1044 | typeof window !== 'undefined' ? window : Function('return this;')(); |
| 597 | daniel-mar | 1045 | |
| 1046 | var name = function (element) { |
||
| 1047 | var r = element.dom.nodeName; |
||
| 1048 | return r.toLowerCase(); |
||
| 1049 | }; |
||
| 637 | daniel-mar | 1050 | var type$1 = function (element) { |
| 597 | daniel-mar | 1051 | return element.dom.nodeType; |
| 1052 | }; |
||
| 637 | daniel-mar | 1053 | var isType = function (t) { |
| 597 | daniel-mar | 1054 | return function (element) { |
| 637 | daniel-mar | 1055 | return type$1(element) === t; |
| 597 | daniel-mar | 1056 | }; |
| 1057 | }; |
||
| 1058 | var isComment = function (element) { |
||
| 637 | daniel-mar | 1059 | return type$1(element) === COMMENT || name(element) === '#comment'; |
| 597 | daniel-mar | 1060 | }; |
| 637 | daniel-mar | 1061 | var isElement = isType(ELEMENT); |
| 1062 | var isText = isType(TEXT); |
||
| 1063 | var isDocument = isType(DOCUMENT); |
||
| 1064 | var isDocumentFragment = isType(DOCUMENT_FRAGMENT); |
||
| 597 | daniel-mar | 1065 | var isTag = function (tag) { |
| 1066 | return function (e) { |
||
| 1067 | return isElement(e) && name(e) === tag; |
||
| 1068 | }; |
||
| 1069 | }; |
||
| 1070 | |||
| 1071 | var owner = function (element) { |
||
| 1072 | return SugarElement.fromDom(element.dom.ownerDocument); |
||
| 1073 | }; |
||
| 1074 | var documentOrOwner = function (dos) { |
||
| 1075 | return isDocument(dos) ? dos : owner(dos); |
||
| 1076 | }; |
||
| 1077 | var defaultView = function (element) { |
||
| 1078 | return SugarElement.fromDom(documentOrOwner(element).dom.defaultView); |
||
| 1079 | }; |
||
| 1080 | var parent = function (element) { |
||
| 1081 | return Optional.from(element.dom.parentNode).map(SugarElement.fromDom); |
||
| 1082 | }; |
||
| 679 | daniel-mar | 1083 | var parentElement = function (element) { |
| 1084 | return Optional.from(element.dom.parentElement).map(SugarElement.fromDom); |
||
| 1085 | }; |
||
| 597 | daniel-mar | 1086 | var parents = function (element, isRoot) { |
| 1087 | var stop = isFunction(isRoot) ? isRoot : never; |
||
| 1088 | var dom = element.dom; |
||
| 1089 | var ret = []; |
||
| 1090 | while (dom.parentNode !== null && dom.parentNode !== undefined) { |
||
| 1091 | var rawParent = dom.parentNode; |
||
| 1092 | var p = SugarElement.fromDom(rawParent); |
||
| 1093 | ret.push(p); |
||
| 1094 | if (stop(p) === true) { |
||
| 1095 | break; |
||
| 1096 | } else { |
||
| 1097 | dom = rawParent; |
||
| 1098 | } |
||
| 1099 | } |
||
| 1100 | return ret; |
||
| 1101 | }; |
||
| 1102 | var prevSibling = function (element) { |
||
| 1103 | return Optional.from(element.dom.previousSibling).map(SugarElement.fromDom); |
||
| 1104 | }; |
||
| 1105 | var nextSibling = function (element) { |
||
| 1106 | return Optional.from(element.dom.nextSibling).map(SugarElement.fromDom); |
||
| 1107 | }; |
||
| 637 | daniel-mar | 1108 | var children$3 = function (element) { |
| 1109 | return map$1(element.dom.childNodes, SugarElement.fromDom); |
||
| 597 | daniel-mar | 1110 | }; |
| 637 | daniel-mar | 1111 | var child$3 = function (element, index) { |
| 597 | daniel-mar | 1112 | var cs = element.dom.childNodes; |
| 1113 | return Optional.from(cs[index]).map(SugarElement.fromDom); |
||
| 1114 | }; |
||
| 1115 | var firstChild = function (element) { |
||
| 637 | daniel-mar | 1116 | return child$3(element, 0); |
| 597 | daniel-mar | 1117 | }; |
| 1118 | |||
| 1119 | var isShadowRoot = function (dos) { |
||
| 1120 | return isDocumentFragment(dos) && isNonNullable(dos.dom.host); |
||
| 1121 | }; |
||
| 1122 | var supported = isFunction(Element.prototype.attachShadow) && isFunction(Node.prototype.getRootNode); |
||
| 637 | daniel-mar | 1123 | var isSupported$1 = constant(supported); |
| 597 | daniel-mar | 1124 | var getRootNode = supported ? function (e) { |
| 1125 | return SugarElement.fromDom(e.dom.getRootNode()); |
||
| 1126 | } : documentOrOwner; |
||
| 1127 | var getShadowRoot = function (e) { |
||
| 1128 | var r = getRootNode(e); |
||
| 1129 | return isShadowRoot(r) ? Optional.some(r) : Optional.none(); |
||
| 1130 | }; |
||
| 1131 | var getShadowHost = function (e) { |
||
| 1132 | return SugarElement.fromDom(e.dom.host); |
||
| 1133 | }; |
||
| 1134 | var getOriginalEventTarget = function (event) { |
||
| 637 | daniel-mar | 1135 | if (isSupported$1() && isNonNullable(event.target)) { |
| 597 | daniel-mar | 1136 | var el = SugarElement.fromDom(event.target); |
| 1137 | if (isElement(el) && isOpenShadowHost(el)) { |
||
| 1138 | if (event.composed && event.composedPath) { |
||
| 1139 | var composedPath = event.composedPath(); |
||
| 1140 | if (composedPath) { |
||
| 1141 | return head(composedPath); |
||
| 1142 | } |
||
| 1143 | } |
||
| 1144 | } |
||
| 1145 | } |
||
| 1146 | return Optional.from(event.target); |
||
| 1147 | }; |
||
| 1148 | var isOpenShadowHost = function (element) { |
||
| 1149 | return isNonNullable(element.dom.shadowRoot); |
||
| 1150 | }; |
||
| 1151 | |||
| 1152 | var inBody = function (element) { |
||
| 1153 | var dom = isText(element) ? element.dom.parentNode : element.dom; |
||
| 1154 | if (dom === undefined || dom === null || dom.ownerDocument === null) { |
||
| 1155 | return false; |
||
| 1156 | } |
||
| 1157 | var doc = dom.ownerDocument; |
||
| 1158 | return getShadowRoot(SugarElement.fromDom(dom)).fold(function () { |
||
| 1159 | return doc.body.contains(dom); |
||
| 1160 | }, compose1(inBody, getShadowHost)); |
||
| 1161 | }; |
||
| 637 | daniel-mar | 1162 | var body$1 = function () { |
| 1163 | return getBody$1(SugarElement.fromDom(document)); |
||
| 597 | daniel-mar | 1164 | }; |
| 637 | daniel-mar | 1165 | var getBody$1 = function (doc) { |
| 597 | daniel-mar | 1166 | var b = doc.dom.body; |
| 1167 | if (b === null || b === undefined) { |
||
| 1168 | throw new Error('Body is not available yet'); |
||
| 1169 | } |
||
| 1170 | return SugarElement.fromDom(b); |
||
| 1171 | }; |
||
| 1172 | |||
| 637 | daniel-mar | 1173 | var ancestors$4 = function (scope, predicate, isRoot) { |
| 1174 | return filter$2(parents(scope, isRoot), predicate); |
||
| 597 | daniel-mar | 1175 | }; |
| 637 | daniel-mar | 1176 | var children$2 = function (scope, predicate) { |
| 1177 | return filter$2(children$3(scope), predicate); |
||
| 597 | daniel-mar | 1178 | }; |
| 637 | daniel-mar | 1179 | var descendants$1 = function (scope, predicate) { |
| 597 | daniel-mar | 1180 | var result = []; |
| 637 | daniel-mar | 1181 | each$2(children$3(scope), function (x) { |
| 597 | daniel-mar | 1182 | if (predicate(x)) { |
| 1183 | result = result.concat([x]); |
||
| 1184 | } |
||
| 637 | daniel-mar | 1185 | result = result.concat(descendants$1(x, predicate)); |
| 597 | daniel-mar | 1186 | }); |
| 1187 | return result; |
||
| 1188 | }; |
||
| 1189 | |||
| 637 | daniel-mar | 1190 | var ancestors$3 = function (scope, selector, isRoot) { |
| 1191 | return ancestors$4(scope, function (e) { |
||
| 1192 | return is$2(e, selector); |
||
| 597 | daniel-mar | 1193 | }, isRoot); |
| 1194 | }; |
||
| 637 | daniel-mar | 1195 | var children$1 = function (scope, selector) { |
| 1196 | return children$2(scope, function (e) { |
||
| 1197 | return is$2(e, selector); |
||
| 597 | daniel-mar | 1198 | }); |
| 1199 | }; |
||
| 637 | daniel-mar | 1200 | var descendants = function (scope, selector) { |
| 1201 | return all$1(selector, scope); |
||
| 597 | daniel-mar | 1202 | }; |
| 1203 | |||
| 1204 | function ClosestOrAncestor (is, ancestor, scope, a, isRoot) { |
||
| 1205 | if (is(scope, a)) { |
||
| 1206 | return Optional.some(scope); |
||
| 1207 | } else if (isFunction(isRoot) && isRoot(scope)) { |
||
| 1208 | return Optional.none(); |
||
| 1209 | } else { |
||
| 1210 | return ancestor(scope, a, isRoot); |
||
| 1211 | } |
||
| 1212 | } |
||
| 1213 | |||
| 637 | daniel-mar | 1214 | var ancestor$2 = function (scope, predicate, isRoot) { |
| 597 | daniel-mar | 1215 | var element = scope.dom; |
| 1216 | var stop = isFunction(isRoot) ? isRoot : never; |
||
| 1217 | while (element.parentNode) { |
||
| 1218 | element = element.parentNode; |
||
| 1219 | var el = SugarElement.fromDom(element); |
||
| 1220 | if (predicate(el)) { |
||
| 1221 | return Optional.some(el); |
||
| 1222 | } else if (stop(el)) { |
||
| 1223 | break; |
||
| 1224 | } |
||
| 1225 | } |
||
| 1226 | return Optional.none(); |
||
| 1227 | }; |
||
| 637 | daniel-mar | 1228 | var closest$2 = function (scope, predicate, isRoot) { |
| 597 | daniel-mar | 1229 | var is = function (s, test) { |
| 1230 | return test(s); |
||
| 1231 | }; |
||
| 637 | daniel-mar | 1232 | return ClosestOrAncestor(is, ancestor$2, scope, predicate, isRoot); |
| 597 | daniel-mar | 1233 | }; |
| 637 | daniel-mar | 1234 | var child$2 = function (scope, predicate) { |
| 597 | daniel-mar | 1235 | var pred = function (node) { |
| 1236 | return predicate(SugarElement.fromDom(node)); |
||
| 1237 | }; |
||
| 637 | daniel-mar | 1238 | var result = find$1(scope.dom.childNodes, pred); |
| 597 | daniel-mar | 1239 | return result.map(SugarElement.fromDom); |
| 1240 | }; |
||
| 637 | daniel-mar | 1241 | var descendant$1 = function (scope, predicate) { |
| 597 | daniel-mar | 1242 | var descend = function (node) { |
| 1243 | for (var i = 0; i < node.childNodes.length; i++) { |
||
| 1244 | var child_1 = SugarElement.fromDom(node.childNodes[i]); |
||
| 1245 | if (predicate(child_1)) { |
||
| 1246 | return Optional.some(child_1); |
||
| 1247 | } |
||
| 1248 | var res = descend(node.childNodes[i]); |
||
| 1249 | if (res.isSome()) { |
||
| 1250 | return res; |
||
| 1251 | } |
||
| 1252 | } |
||
| 1253 | return Optional.none(); |
||
| 1254 | }; |
||
| 1255 | return descend(scope.dom); |
||
| 1256 | }; |
||
| 1257 | |||
| 1258 | var ancestor$1 = function (scope, selector, isRoot) { |
||
| 637 | daniel-mar | 1259 | return ancestor$2(scope, function (e) { |
| 1260 | return is$2(e, selector); |
||
| 597 | daniel-mar | 1261 | }, isRoot); |
| 1262 | }; |
||
| 637 | daniel-mar | 1263 | var child$1 = function (scope, selector) { |
| 1264 | return child$2(scope, function (e) { |
||
| 1265 | return is$2(e, selector); |
||
| 597 | daniel-mar | 1266 | }); |
| 1267 | }; |
||
| 637 | daniel-mar | 1268 | var descendant = function (scope, selector) { |
| 597 | daniel-mar | 1269 | return one(selector, scope); |
| 1270 | }; |
||
| 1271 | var closest$1 = function (scope, selector, isRoot) { |
||
| 637 | daniel-mar | 1272 | var is = function (element, selector) { |
| 1273 | return is$2(element, selector); |
||
| 597 | daniel-mar | 1274 | }; |
| 637 | daniel-mar | 1275 | return ClosestOrAncestor(is, ancestor$1, scope, selector, isRoot); |
| 597 | daniel-mar | 1276 | }; |
| 1277 | |||
| 1278 | var rawSet = function (dom, key, value) { |
||
| 1279 | if (isString(value) || isBoolean(value) || isNumber(value)) { |
||
| 1280 | dom.setAttribute(key, value + ''); |
||
| 1281 | } else { |
||
| 1282 | console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom); |
||
| 1283 | throw new Error('Attribute value was not simple'); |
||
| 1284 | } |
||
| 1285 | }; |
||
| 637 | daniel-mar | 1286 | var set$2 = function (element, key, value) { |
| 597 | daniel-mar | 1287 | rawSet(element.dom, key, value); |
| 1288 | }; |
||
| 637 | daniel-mar | 1289 | var setAll$1 = function (element, attrs) { |
| 597 | daniel-mar | 1290 | var dom = element.dom; |
| 1291 | each$1(attrs, function (v, k) { |
||
| 1292 | rawSet(dom, k, v); |
||
| 1293 | }); |
||
| 1294 | }; |
||
| 679 | daniel-mar | 1295 | var setOptions = function (element, attrs) { |
| 1296 | each$1(attrs, function (v, k) { |
||
| 1297 | v.fold(function () { |
||
| 1298 | remove$7(element, k); |
||
| 1299 | }, function (value) { |
||
| 1300 | rawSet(element.dom, k, value); |
||
| 1301 | }); |
||
| 1302 | }); |
||
| 1303 | }; |
||
| 637 | daniel-mar | 1304 | var get$b = function (element, key) { |
| 597 | daniel-mar | 1305 | var v = element.dom.getAttribute(key); |
| 1306 | return v === null ? undefined : v; |
||
| 1307 | }; |
||
| 1308 | var getOpt = function (element, key) { |
||
| 637 | daniel-mar | 1309 | return Optional.from(get$b(element, key)); |
| 597 | daniel-mar | 1310 | }; |
| 637 | daniel-mar | 1311 | var remove$7 = function (element, key) { |
| 597 | daniel-mar | 1312 | element.dom.removeAttribute(key); |
| 1313 | }; |
||
| 637 | daniel-mar | 1314 | var clone$2 = function (element) { |
| 597 | daniel-mar | 1315 | return foldl(element.dom.attributes, function (acc, attr) { |
| 1316 | acc[attr.name] = attr.value; |
||
| 1317 | return acc; |
||
| 1318 | }, {}); |
||
| 1319 | }; |
||
| 1320 | |||
| 637 | daniel-mar | 1321 | var is = function (lhs, rhs, comparator) { |
| 1322 | if (comparator === void 0) { |
||
| 1323 | comparator = tripleEquals; |
||
| 1324 | } |
||
| 1325 | return lhs.exists(function (left) { |
||
| 1326 | return comparator(left, rhs); |
||
| 1327 | }); |
||
| 1328 | }; |
||
| 1329 | var cat = function (arr) { |
||
| 1330 | var r = []; |
||
| 1331 | var push = function (x) { |
||
| 1332 | r.push(x); |
||
| 1333 | }; |
||
| 1334 | for (var i = 0; i < arr.length; i++) { |
||
| 1335 | arr[i].each(push); |
||
| 1336 | } |
||
| 1337 | return r; |
||
| 1338 | }; |
||
| 1339 | var lift2 = function (oa, ob, f) { |
||
| 1340 | return oa.isSome() && ob.isSome() ? Optional.some(f(oa.getOrDie(), ob.getOrDie())) : Optional.none(); |
||
| 1341 | }; |
||
| 1342 | var bindFrom = function (a, f) { |
||
| 1343 | return a !== undefined && a !== null ? f(a) : Optional.none(); |
||
| 1344 | }; |
||
| 1345 | var flatten = function (oot) { |
||
| 1346 | return oot.bind(identity); |
||
| 1347 | }; |
||
| 1348 | var someIf = function (b, a) { |
||
| 1349 | return b ? Optional.some(a) : Optional.none(); |
||
| 1350 | }; |
||
| 1351 | |||
| 1352 | var isSupported = function (dom) { |
||
| 597 | daniel-mar | 1353 | return dom.style !== undefined && isFunction(dom.style.getPropertyValue); |
| 1354 | }; |
||
| 1355 | |||
| 1356 | var internalSet = function (dom, property, value) { |
||
| 1357 | if (!isString(value)) { |
||
| 1358 | console.error('Invalid call to CSS.set. Property ', property, ':: Value ', value, ':: Element ', dom); |
||
| 1359 | throw new Error('CSS value must be a string: ' + value); |
||
| 1360 | } |
||
| 637 | daniel-mar | 1361 | if (isSupported(dom)) { |
| 597 | daniel-mar | 1362 | dom.style.setProperty(property, value); |
| 1363 | } |
||
| 1364 | }; |
||
| 1365 | var internalRemove = function (dom, property) { |
||
| 637 | daniel-mar | 1366 | if (isSupported(dom)) { |
| 597 | daniel-mar | 1367 | dom.style.removeProperty(property); |
| 1368 | } |
||
| 1369 | }; |
||
| 1370 | var set$1 = function (element, property, value) { |
||
| 1371 | var dom = element.dom; |
||
| 1372 | internalSet(dom, property, value); |
||
| 1373 | }; |
||
| 637 | daniel-mar | 1374 | var setAll = function (element, css) { |
| 597 | daniel-mar | 1375 | var dom = element.dom; |
| 1376 | each$1(css, function (v, k) { |
||
| 1377 | internalSet(dom, k, v); |
||
| 1378 | }); |
||
| 1379 | }; |
||
| 637 | daniel-mar | 1380 | var get$a = function (element, property) { |
| 597 | daniel-mar | 1381 | var dom = element.dom; |
| 1382 | var styles = window.getComputedStyle(dom); |
||
| 1383 | var r = styles.getPropertyValue(property); |
||
| 1384 | return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r; |
||
| 1385 | }; |
||
| 1386 | var getUnsafeProperty = function (dom, property) { |
||
| 637 | daniel-mar | 1387 | return isSupported(dom) ? dom.style.getPropertyValue(property) : ''; |
| 597 | daniel-mar | 1388 | }; |
| 637 | daniel-mar | 1389 | var getRaw$2 = function (element, property) { |
| 597 | daniel-mar | 1390 | var dom = element.dom; |
| 1391 | var raw = getUnsafeProperty(dom, property); |
||
| 1392 | return Optional.from(raw).filter(function (r) { |
||
| 1393 | return r.length > 0; |
||
| 1394 | }); |
||
| 1395 | }; |
||
| 637 | daniel-mar | 1396 | var remove$6 = function (element, property) { |
| 597 | daniel-mar | 1397 | var dom = element.dom; |
| 1398 | internalRemove(dom, property); |
||
| 637 | daniel-mar | 1399 | if (is(getOpt(element, 'style').map(trim), '')) { |
| 1400 | remove$7(element, 'style'); |
||
| 597 | daniel-mar | 1401 | } |
| 1402 | }; |
||
| 637 | daniel-mar | 1403 | var copy$2 = function (source, target) { |
| 597 | daniel-mar | 1404 | var sourceDom = source.dom; |
| 1405 | var targetDom = target.dom; |
||
| 637 | daniel-mar | 1406 | if (isSupported(sourceDom) && isSupported(targetDom)) { |
| 597 | daniel-mar | 1407 | targetDom.style.cssText = sourceDom.style.cssText; |
| 1408 | } |
||
| 1409 | }; |
||
| 1410 | |||
| 1411 | var getAttrValue = function (cell, name, fallback) { |
||
| 1412 | if (fallback === void 0) { |
||
| 1413 | fallback = 0; |
||
| 1414 | } |
||
| 1415 | return getOpt(cell, name).map(function (value) { |
||
| 1416 | return parseInt(value, 10); |
||
| 1417 | }).getOr(fallback); |
||
| 1418 | }; |
||
| 1419 | var getSpan = function (cell, type) { |
||
| 1420 | return getAttrValue(cell, type, 1); |
||
| 1421 | }; |
||
| 679 | daniel-mar | 1422 | var hasColspan = function (cellOrCol) { |
| 1423 | if (isTag('col')(cellOrCol)) { |
||
| 1424 | return getAttrValue(cellOrCol, 'span', 1) > 1; |
||
| 1425 | } else { |
||
| 1426 | return getSpan(cellOrCol, 'colspan') > 1; |
||
| 1427 | } |
||
| 597 | daniel-mar | 1428 | }; |
| 1429 | var hasRowspan = function (cell) { |
||
| 1430 | return getSpan(cell, 'rowspan') > 1; |
||
| 1431 | }; |
||
| 1432 | var getCssValue = function (element, property) { |
||
| 637 | daniel-mar | 1433 | return parseInt(get$a(element, property), 10); |
| 597 | daniel-mar | 1434 | }; |
| 1435 | var minWidth = constant(10); |
||
| 1436 | var minHeight = constant(10); |
||
| 1437 | |||
| 1438 | var firstLayer = function (scope, selector) { |
||
| 1439 | return filterFirstLayer(scope, selector, always); |
||
| 1440 | }; |
||
| 1441 | var filterFirstLayer = function (scope, selector, predicate) { |
||
| 637 | daniel-mar | 1442 | return bind$2(children$3(scope), function (x) { |
| 1443 | if (is$2(x, selector)) { |
||
| 597 | daniel-mar | 1444 | return predicate(x) ? [x] : []; |
| 1445 | } else { |
||
| 1446 | return filterFirstLayer(x, selector, predicate); |
||
| 1447 | } |
||
| 1448 | }); |
||
| 1449 | }; |
||
| 1450 | |||
| 1451 | var lookup = function (tags, element, isRoot) { |
||
| 1452 | if (isRoot === void 0) { |
||
| 1453 | isRoot = never; |
||
| 1454 | } |
||
| 1455 | if (isRoot(element)) { |
||
| 1456 | return Optional.none(); |
||
| 1457 | } |
||
| 637 | daniel-mar | 1458 | if (contains$2(tags, name(element))) { |
| 597 | daniel-mar | 1459 | return Optional.some(element); |
| 1460 | } |
||
| 1461 | var isRootOrUpperTable = function (elm) { |
||
| 637 | daniel-mar | 1462 | return is$2(elm, 'table') || isRoot(elm); |
| 597 | daniel-mar | 1463 | }; |
| 1464 | return ancestor$1(element, tags.join(','), isRootOrUpperTable); |
||
| 1465 | }; |
||
| 1466 | var cell = function (element, isRoot) { |
||
| 1467 | return lookup([ |
||
| 1468 | 'td', |
||
| 1469 | 'th' |
||
| 1470 | ], element, isRoot); |
||
| 1471 | }; |
||
| 637 | daniel-mar | 1472 | var cells$1 = function (ancestor) { |
| 597 | daniel-mar | 1473 | return firstLayer(ancestor, 'th,td'); |
| 1474 | }; |
||
| 637 | daniel-mar | 1475 | var columns$1 = function (ancestor) { |
| 1476 | if (is$2(ancestor, 'colgroup')) { |
||
| 1477 | return children$1(ancestor, 'col'); |
||
| 597 | daniel-mar | 1478 | } else { |
| 637 | daniel-mar | 1479 | return bind$2(columnGroups(ancestor), function (columnGroup) { |
| 1480 | return children$1(columnGroup, 'col'); |
||
| 597 | daniel-mar | 1481 | }); |
| 1482 | } |
||
| 1483 | }; |
||
| 1484 | var table = function (element, isRoot) { |
||
| 1485 | return closest$1(element, 'table', isRoot); |
||
| 1486 | }; |
||
| 637 | daniel-mar | 1487 | var rows$1 = function (ancestor) { |
| 597 | daniel-mar | 1488 | return firstLayer(ancestor, 'tr'); |
| 1489 | }; |
||
| 1490 | var columnGroups = function (ancestor) { |
||
| 1491 | return table(ancestor).fold(constant([]), function (table) { |
||
| 637 | daniel-mar | 1492 | return children$1(table, 'colgroup'); |
| 597 | daniel-mar | 1493 | }); |
| 1494 | }; |
||
| 1495 | |||
| 1496 | var fromRowsOrColGroups = function (elems, getSection) { |
||
| 637 | daniel-mar | 1497 | return map$1(elems, function (row) { |
| 597 | daniel-mar | 1498 | if (name(row) === 'colgroup') { |
| 637 | daniel-mar | 1499 | var cells = map$1(columns$1(row), function (column) { |
| 597 | daniel-mar | 1500 | var colspan = getAttrValue(column, 'span', 1); |
| 1501 | return detail(column, 1, colspan); |
||
| 1502 | }); |
||
| 637 | daniel-mar | 1503 | return rowdetail(row, cells, 'colgroup'); |
| 597 | daniel-mar | 1504 | } else { |
| 637 | daniel-mar | 1505 | var cells = map$1(cells$1(row), function (cell) { |
| 597 | daniel-mar | 1506 | var rowspan = getAttrValue(cell, 'rowspan', 1); |
| 1507 | var colspan = getAttrValue(cell, 'colspan', 1); |
||
| 1508 | return detail(cell, rowspan, colspan); |
||
| 1509 | }); |
||
| 637 | daniel-mar | 1510 | return rowdetail(row, cells, getSection(row)); |
| 597 | daniel-mar | 1511 | } |
| 1512 | }); |
||
| 1513 | }; |
||
| 1514 | var getParentSection = function (group) { |
||
| 1515 | return parent(group).map(function (parent) { |
||
| 1516 | var parentName = name(parent); |
||
| 1517 | return isValidSection(parentName) ? parentName : 'tbody'; |
||
| 1518 | }).getOr('tbody'); |
||
| 1519 | }; |
||
| 637 | daniel-mar | 1520 | var fromTable$1 = function (table) { |
| 1521 | var rows = rows$1(table); |
||
| 597 | daniel-mar | 1522 | var columnGroups$1 = columnGroups(table); |
| 679 | daniel-mar | 1523 | var elems = __spreadArray(__spreadArray([], columnGroups$1, true), rows, true); |
| 597 | daniel-mar | 1524 | return fromRowsOrColGroups(elems, getParentSection); |
| 1525 | }; |
||
| 1526 | var fromPastedRows = function (elems, section) { |
||
| 1527 | return fromRowsOrColGroups(elems, function () { |
||
| 1528 | return section; |
||
| 1529 | }); |
||
| 1530 | }; |
||
| 1531 | |||
| 1532 | var addCells = function (gridRow, index, cells) { |
||
| 1533 | var existingCells = gridRow.cells; |
||
| 1534 | var before = existingCells.slice(0, index); |
||
| 1535 | var after = existingCells.slice(index); |
||
| 1536 | var newCells = before.concat(cells).concat(after); |
||
| 1537 | return setCells(gridRow, newCells); |
||
| 1538 | }; |
||
| 1539 | var addCell = function (gridRow, index, cell) { |
||
| 1540 | return addCells(gridRow, index, [cell]); |
||
| 1541 | }; |
||
| 1542 | var mutateCell = function (gridRow, index, cell) { |
||
| 1543 | var cells = gridRow.cells; |
||
| 1544 | cells[index] = cell; |
||
| 1545 | }; |
||
| 1546 | var setCells = function (gridRow, cells) { |
||
| 637 | daniel-mar | 1547 | return rowcells(gridRow.element, cells, gridRow.section, gridRow.isNew); |
| 597 | daniel-mar | 1548 | }; |
| 1549 | var mapCells = function (gridRow, f) { |
||
| 1550 | var cells = gridRow.cells; |
||
| 637 | daniel-mar | 1551 | var r = map$1(cells, f); |
| 1552 | return rowcells(gridRow.element, r, gridRow.section, gridRow.isNew); |
||
| 597 | daniel-mar | 1553 | }; |
| 1554 | var getCell = function (gridRow, index) { |
||
| 1555 | return gridRow.cells[index]; |
||
| 1556 | }; |
||
| 1557 | var getCellElement = function (gridRow, index) { |
||
| 1558 | return getCell(gridRow, index).element; |
||
| 1559 | }; |
||
| 1560 | var cellLength = function (gridRow) { |
||
| 1561 | return gridRow.cells.length; |
||
| 1562 | }; |
||
| 1563 | var extractGridDetails = function (grid) { |
||
| 1564 | var result = partition(grid, function (row) { |
||
| 1565 | return row.section === 'colgroup'; |
||
| 1566 | }); |
||
| 1567 | return { |
||
| 1568 | rows: result.fail, |
||
| 1569 | cols: result.pass |
||
| 1570 | }; |
||
| 1571 | }; |
||
| 637 | daniel-mar | 1572 | var clone$1 = function (gridRow, cloneRow, cloneCell) { |
| 1573 | var newCells = map$1(gridRow.cells, cloneCell); |
||
| 1574 | return rowcells(cloneRow(gridRow.element), newCells, gridRow.section, true); |
||
| 1575 | }; |
||
| 597 | daniel-mar | 1576 | |
| 1577 | var LOCKED_COL_ATTR = 'data-snooker-locked-cols'; |
||
| 1578 | var getLockedColumnsFromTable = function (table) { |
||
| 1579 | return getOpt(table, LOCKED_COL_ATTR).bind(function (lockedColStr) { |
||
| 1580 | return Optional.from(lockedColStr.match(/\d+/g)); |
||
| 1581 | }).map(function (lockedCols) { |
||
| 1582 | return mapToObject(lockedCols, always); |
||
| 1583 | }); |
||
| 1584 | }; |
||
| 1585 | var getLockedColumnsFromGrid = function (grid) { |
||
| 1586 | var locked = foldl(extractGridDetails(grid).rows, function (acc, row) { |
||
| 637 | daniel-mar | 1587 | each$2(row.cells, function (cell, idx) { |
| 597 | daniel-mar | 1588 | if (cell.isLocked) { |
| 1589 | acc[idx] = true; |
||
| 1590 | } |
||
| 1591 | }); |
||
| 1592 | return acc; |
||
| 1593 | }, {}); |
||
| 1594 | var lockedArr = mapToArray(locked, function (_val, key) { |
||
| 1595 | return parseInt(key, 10); |
||
| 1596 | }); |
||
| 637 | daniel-mar | 1597 | return sort$1(lockedArr); |
| 597 | daniel-mar | 1598 | }; |
| 1599 | |||
| 1600 | var key = function (row, column) { |
||
| 1601 | return row + ',' + column; |
||
| 1602 | }; |
||
| 1603 | var getAt = function (warehouse, row, column) { |
||
| 637 | daniel-mar | 1604 | return Optional.from(warehouse.access[key(row, column)]); |
| 597 | daniel-mar | 1605 | }; |
| 1606 | var findItem = function (warehouse, item, comparator) { |
||
| 1607 | var filtered = filterItems(warehouse, function (detail) { |
||
| 1608 | return comparator(item, detail.element); |
||
| 1609 | }); |
||
| 1610 | return filtered.length > 0 ? Optional.some(filtered[0]) : Optional.none(); |
||
| 1611 | }; |
||
| 1612 | var filterItems = function (warehouse, predicate) { |
||
| 637 | daniel-mar | 1613 | var all = bind$2(warehouse.all, function (r) { |
| 597 | daniel-mar | 1614 | return r.cells; |
| 1615 | }); |
||
| 637 | daniel-mar | 1616 | return filter$2(all, predicate); |
| 597 | daniel-mar | 1617 | }; |
| 1618 | var generateColumns = function (rowData) { |
||
| 1619 | var columnsGroup = {}; |
||
| 1620 | var index = 0; |
||
| 637 | daniel-mar | 1621 | each$2(rowData.cells, function (column) { |
| 597 | daniel-mar | 1622 | var colspan = column.colspan; |
| 637 | daniel-mar | 1623 | range$1(colspan, function (columnIndex) { |
| 597 | daniel-mar | 1624 | var colIndex = index + columnIndex; |
| 1625 | columnsGroup[colIndex] = columnext(column.element, colspan, colIndex); |
||
| 1626 | }); |
||
| 1627 | index += colspan; |
||
| 1628 | }); |
||
| 1629 | return columnsGroup; |
||
| 1630 | }; |
||
| 637 | daniel-mar | 1631 | var generate$1 = function (list) { |
| 597 | daniel-mar | 1632 | var access = {}; |
| 1633 | var cells = []; |
||
| 1634 | var tableOpt = head(list).map(function (rowData) { |
||
| 1635 | return rowData.element; |
||
| 1636 | }).bind(table); |
||
| 1637 | var lockedColumns = tableOpt.bind(getLockedColumnsFromTable).getOr({}); |
||
| 1638 | var maxRows = 0; |
||
| 1639 | var maxColumns = 0; |
||
| 1640 | var rowCount = 0; |
||
| 679 | daniel-mar | 1641 | var _a = partition(list, function (rowData) { |
| 1642 | return rowData.section === 'colgroup'; |
||
| 1643 | }), colgroupRows = _a.pass, rows = _a.fail; |
||
| 1644 | each$2(rows, function (rowData) { |
||
| 1645 | var currentRow = []; |
||
| 1646 | each$2(rowData.cells, function (rowCell) { |
||
| 1647 | var start = 0; |
||
| 1648 | while (access[key(rowCount, start)] !== undefined) { |
||
| 1649 | start++; |
||
| 1650 | } |
||
| 1651 | var isLocked = hasNonNullableKey(lockedColumns, start.toString()); |
||
| 1652 | var current = extended(rowCell.element, rowCell.rowspan, rowCell.colspan, rowCount, start, isLocked); |
||
| 1653 | for (var occupiedColumnPosition = 0; occupiedColumnPosition < rowCell.colspan; occupiedColumnPosition++) { |
||
| 1654 | for (var occupiedRowPosition = 0; occupiedRowPosition < rowCell.rowspan; occupiedRowPosition++) { |
||
| 1655 | var rowPosition = rowCount + occupiedRowPosition; |
||
| 1656 | var columnPosition = start + occupiedColumnPosition; |
||
| 1657 | var newpos = key(rowPosition, columnPosition); |
||
| 1658 | access[newpos] = current; |
||
| 1659 | maxColumns = Math.max(maxColumns, columnPosition + 1); |
||
| 597 | daniel-mar | 1660 | } |
| 679 | daniel-mar | 1661 | } |
| 1662 | currentRow.push(current); |
||
| 1663 | }); |
||
| 1664 | maxRows++; |
||
| 1665 | cells.push(rowdetail(rowData.element, currentRow, rowData.section)); |
||
| 1666 | rowCount++; |
||
| 597 | daniel-mar | 1667 | }); |
| 679 | daniel-mar | 1668 | var _b = last$2(colgroupRows).map(function (rowData) { |
| 1669 | var columns = generateColumns(rowData); |
||
| 1670 | var colgroup$1 = colgroup(rowData.element, values(columns)); |
||
| 1671 | return { |
||
| 1672 | colgroups: [colgroup$1], |
||
| 1673 | columns: columns |
||
| 1674 | }; |
||
| 1675 | }).getOrThunk(function () { |
||
| 1676 | return { |
||
| 1677 | colgroups: [], |
||
| 1678 | columns: {} |
||
| 1679 | }; |
||
| 1680 | }), columns = _b.columns, colgroups = _b.colgroups; |
||
| 597 | daniel-mar | 1681 | var grid$1 = grid(maxRows, maxColumns); |
| 1682 | return { |
||
| 1683 | grid: grid$1, |
||
| 1684 | access: access, |
||
| 1685 | all: cells, |
||
| 637 | daniel-mar | 1686 | columns: columns, |
| 1687 | colgroups: colgroups |
||
| 597 | daniel-mar | 1688 | }; |
| 1689 | }; |
||
| 637 | daniel-mar | 1690 | var fromTable = function (table) { |
| 1691 | var list = fromTable$1(table); |
||
| 1692 | return generate$1(list); |
||
| 597 | daniel-mar | 1693 | }; |
| 1694 | var justCells = function (warehouse) { |
||
| 637 | daniel-mar | 1695 | return bind$2(warehouse.all, function (w) { |
| 597 | daniel-mar | 1696 | return w.cells; |
| 1697 | }); |
||
| 1698 | }; |
||
| 1699 | var justColumns = function (warehouse) { |
||
| 1700 | return values(warehouse.columns); |
||
| 1701 | }; |
||
| 1702 | var hasColumns = function (warehouse) { |
||
| 1703 | return keys(warehouse.columns).length > 0; |
||
| 1704 | }; |
||
| 1705 | var getColumnAt = function (warehouse, columnIndex) { |
||
| 1706 | return Optional.from(warehouse.columns[columnIndex]); |
||
| 1707 | }; |
||
| 1708 | var Warehouse = { |
||
| 637 | daniel-mar | 1709 | fromTable: fromTable, |
| 1710 | generate: generate$1, |
||
| 597 | daniel-mar | 1711 | getAt: getAt, |
| 1712 | findItem: findItem, |
||
| 1713 | filterItems: filterItems, |
||
| 1714 | justCells: justCells, |
||
| 1715 | justColumns: justColumns, |
||
| 1716 | hasColumns: hasColumns, |
||
| 1717 | getColumnAt: getColumnAt |
||
| 1718 | }; |
||
| 1719 | |||
| 1720 | var inSelection = function (bounds, detail) { |
||
| 1721 | var leftEdge = detail.column; |
||
| 1722 | var rightEdge = detail.column + detail.colspan - 1; |
||
| 1723 | var topEdge = detail.row; |
||
| 1724 | var bottomEdge = detail.row + detail.rowspan - 1; |
||
| 1725 | return leftEdge <= bounds.finishCol && rightEdge >= bounds.startCol && (topEdge <= bounds.finishRow && bottomEdge >= bounds.startRow); |
||
| 1726 | }; |
||
| 1727 | var isWithin = function (bounds, detail) { |
||
| 1728 | return detail.column >= bounds.startCol && detail.column + detail.colspan - 1 <= bounds.finishCol && detail.row >= bounds.startRow && detail.row + detail.rowspan - 1 <= bounds.finishRow; |
||
| 1729 | }; |
||
| 1730 | var isRectangular = function (warehouse, bounds) { |
||
| 1731 | var isRect = true; |
||
| 1732 | var detailIsWithin = curry(isWithin, bounds); |
||
| 1733 | for (var i = bounds.startRow; i <= bounds.finishRow; i++) { |
||
| 1734 | for (var j = bounds.startCol; j <= bounds.finishCol; j++) { |
||
| 1735 | isRect = isRect && Warehouse.getAt(warehouse, i, j).exists(detailIsWithin); |
||
| 1736 | } |
||
| 1737 | } |
||
| 1738 | return isRect ? Optional.some(bounds) : Optional.none(); |
||
| 1739 | }; |
||
| 1740 | |||
| 1741 | var getBounds = function (detailA, detailB) { |
||
| 1742 | return bounds(Math.min(detailA.row, detailB.row), Math.min(detailA.column, detailB.column), Math.max(detailA.row + detailA.rowspan - 1, detailB.row + detailB.rowspan - 1), Math.max(detailA.column + detailA.colspan - 1, detailB.column + detailB.colspan - 1)); |
||
| 1743 | }; |
||
| 1744 | var getAnyBox = function (warehouse, startCell, finishCell) { |
||
| 1745 | var startCoords = Warehouse.findItem(warehouse, startCell, eq$1); |
||
| 1746 | var finishCoords = Warehouse.findItem(warehouse, finishCell, eq$1); |
||
| 1747 | return startCoords.bind(function (sc) { |
||
| 1748 | return finishCoords.map(function (fc) { |
||
| 1749 | return getBounds(sc, fc); |
||
| 1750 | }); |
||
| 1751 | }); |
||
| 1752 | }; |
||
| 637 | daniel-mar | 1753 | var getBox$1 = function (warehouse, startCell, finishCell) { |
| 597 | daniel-mar | 1754 | return getAnyBox(warehouse, startCell, finishCell).bind(function (bounds) { |
| 1755 | return isRectangular(warehouse, bounds); |
||
| 1756 | }); |
||
| 1757 | }; |
||
| 1758 | |||
| 637 | daniel-mar | 1759 | var moveBy$1 = function (warehouse, cell, row, column) { |
| 597 | daniel-mar | 1760 | return Warehouse.findItem(warehouse, cell, eq$1).bind(function (detail) { |
| 1761 | var startRow = row > 0 ? detail.row + detail.rowspan - 1 : detail.row; |
||
| 1762 | var startCol = column > 0 ? detail.column + detail.colspan - 1 : detail.column; |
||
| 1763 | var dest = Warehouse.getAt(warehouse, startRow + row, startCol + column); |
||
| 1764 | return dest.map(function (d) { |
||
| 1765 | return d.element; |
||
| 1766 | }); |
||
| 1767 | }); |
||
| 1768 | }; |
||
| 637 | daniel-mar | 1769 | var intercepts$1 = function (warehouse, start, finish) { |
| 597 | daniel-mar | 1770 | return getAnyBox(warehouse, start, finish).map(function (bounds) { |
| 1771 | var inside = Warehouse.filterItems(warehouse, curry(inSelection, bounds)); |
||
| 637 | daniel-mar | 1772 | return map$1(inside, function (detail) { |
| 597 | daniel-mar | 1773 | return detail.element; |
| 1774 | }); |
||
| 1775 | }); |
||
| 1776 | }; |
||
| 1777 | var parentCell = function (warehouse, innerCell) { |
||
| 1778 | var isContainedBy = function (c1, c2) { |
||
| 637 | daniel-mar | 1779 | return contains(c2, c1); |
| 597 | daniel-mar | 1780 | }; |
| 1781 | return Warehouse.findItem(warehouse, innerCell, isContainedBy).map(function (detail) { |
||
| 1782 | return detail.element; |
||
| 1783 | }); |
||
| 1784 | }; |
||
| 1785 | |||
| 637 | daniel-mar | 1786 | var moveBy = function (cell, deltaRow, deltaColumn) { |
| 597 | daniel-mar | 1787 | return table(cell).bind(function (table) { |
| 1788 | var warehouse = getWarehouse(table); |
||
| 637 | daniel-mar | 1789 | return moveBy$1(warehouse, cell, deltaRow, deltaColumn); |
| 597 | daniel-mar | 1790 | }); |
| 1791 | }; |
||
| 637 | daniel-mar | 1792 | var intercepts = function (table, first, last) { |
| 597 | daniel-mar | 1793 | var warehouse = getWarehouse(table); |
| 637 | daniel-mar | 1794 | return intercepts$1(warehouse, first, last); |
| 597 | daniel-mar | 1795 | }; |
| 1796 | var nestedIntercepts = function (table, first, firstTable, last, lastTable) { |
||
| 1797 | var warehouse = getWarehouse(table); |
||
| 1798 | var optStartCell = eq$1(table, firstTable) ? Optional.some(first) : parentCell(warehouse, first); |
||
| 1799 | var optLastCell = eq$1(table, lastTable) ? Optional.some(last) : parentCell(warehouse, last); |
||
| 1800 | return optStartCell.bind(function (startCell) { |
||
| 1801 | return optLastCell.bind(function (lastCell) { |
||
| 637 | daniel-mar | 1802 | return intercepts$1(warehouse, startCell, lastCell); |
| 597 | daniel-mar | 1803 | }); |
| 1804 | }); |
||
| 1805 | }; |
||
| 637 | daniel-mar | 1806 | var getBox = function (table, first, last) { |
| 597 | daniel-mar | 1807 | var warehouse = getWarehouse(table); |
| 637 | daniel-mar | 1808 | return getBox$1(warehouse, first, last); |
| 597 | daniel-mar | 1809 | }; |
| 1810 | var getWarehouse = Warehouse.fromTable; |
||
| 1811 | |||
| 637 | daniel-mar | 1812 | var before$4 = function (marker, element) { |
| 597 | daniel-mar | 1813 | var parent$1 = parent(marker); |
| 1814 | parent$1.each(function (v) { |
||
| 1815 | v.dom.insertBefore(element.dom, marker.dom); |
||
| 1816 | }); |
||
| 1817 | }; |
||
| 637 | daniel-mar | 1818 | var after$5 = function (marker, element) { |
| 597 | daniel-mar | 1819 | var sibling = nextSibling(marker); |
| 1820 | sibling.fold(function () { |
||
| 1821 | var parent$1 = parent(marker); |
||
| 1822 | parent$1.each(function (v) { |
||
| 637 | daniel-mar | 1823 | append$1(v, element); |
| 597 | daniel-mar | 1824 | }); |
| 1825 | }, function (v) { |
||
| 637 | daniel-mar | 1826 | before$4(v, element); |
| 597 | daniel-mar | 1827 | }); |
| 1828 | }; |
||
| 1829 | var prepend = function (parent, element) { |
||
| 1830 | var firstChild$1 = firstChild(parent); |
||
| 1831 | firstChild$1.fold(function () { |
||
| 637 | daniel-mar | 1832 | append$1(parent, element); |
| 597 | daniel-mar | 1833 | }, function (v) { |
| 1834 | parent.dom.insertBefore(element.dom, v.dom); |
||
| 1835 | }); |
||
| 1836 | }; |
||
| 637 | daniel-mar | 1837 | var append$1 = function (parent, element) { |
| 597 | daniel-mar | 1838 | parent.dom.appendChild(element.dom); |
| 1839 | }; |
||
| 637 | daniel-mar | 1840 | var appendAt = function (parent, element, index) { |
| 1841 | child$3(parent, index).fold(function () { |
||
| 1842 | append$1(parent, element); |
||
| 1843 | }, function (v) { |
||
| 1844 | before$4(v, element); |
||
| 1845 | }); |
||
| 1846 | }; |
||
| 597 | daniel-mar | 1847 | var wrap = function (element, wrapper) { |
| 637 | daniel-mar | 1848 | before$4(element, wrapper); |
| 1849 | append$1(wrapper, element); |
||
| 597 | daniel-mar | 1850 | }; |
| 1851 | |||
| 637 | daniel-mar | 1852 | var before$3 = function (marker, elements) { |
| 1853 | each$2(elements, function (x) { |
||
| 1854 | before$4(marker, x); |
||
| 597 | daniel-mar | 1855 | }); |
| 1856 | }; |
||
| 637 | daniel-mar | 1857 | var after$4 = function (marker, elements) { |
| 1858 | each$2(elements, function (x, i) { |
||
| 597 | daniel-mar | 1859 | var e = i === 0 ? marker : elements[i - 1]; |
| 637 | daniel-mar | 1860 | after$5(e, x); |
| 597 | daniel-mar | 1861 | }); |
| 1862 | }; |
||
| 637 | daniel-mar | 1863 | var append = function (parent, elements) { |
| 1864 | each$2(elements, function (x) { |
||
| 1865 | append$1(parent, x); |
||
| 597 | daniel-mar | 1866 | }); |
| 1867 | }; |
||
| 1868 | |||
| 1869 | var empty = function (element) { |
||
| 1870 | element.dom.textContent = ''; |
||
| 637 | daniel-mar | 1871 | each$2(children$3(element), function (rogue) { |
| 1872 | remove$5(rogue); |
||
| 597 | daniel-mar | 1873 | }); |
| 1874 | }; |
||
| 637 | daniel-mar | 1875 | var remove$5 = function (element) { |
| 597 | daniel-mar | 1876 | var dom = element.dom; |
| 1877 | if (dom.parentNode !== null) { |
||
| 1878 | dom.parentNode.removeChild(dom); |
||
| 1879 | } |
||
| 1880 | }; |
||
| 1881 | var unwrap = function (wrapper) { |
||
| 637 | daniel-mar | 1882 | var children = children$3(wrapper); |
| 1883 | if (children.length > 0) { |
||
| 1884 | before$3(wrapper, children); |
||
| 597 | daniel-mar | 1885 | } |
| 637 | daniel-mar | 1886 | remove$5(wrapper); |
| 597 | daniel-mar | 1887 | }; |
| 1888 | |||
| 1889 | var NodeValue = function (is, name) { |
||
| 1890 | var get = function (element) { |
||
| 1891 | if (!is(element)) { |
||
| 1892 | throw new Error('Can only get ' + name + ' value of a ' + name + ' node'); |
||
| 1893 | } |
||
| 1894 | return getOption(element).getOr(''); |
||
| 1895 | }; |
||
| 1896 | var getOption = function (element) { |
||
| 1897 | return is(element) ? Optional.from(element.dom.nodeValue) : Optional.none(); |
||
| 1898 | }; |
||
| 1899 | var set = function (element, value) { |
||
| 1900 | if (!is(element)) { |
||
| 1901 | throw new Error('Can only set raw ' + name + ' value of a ' + name + ' node'); |
||
| 1902 | } |
||
| 1903 | element.dom.nodeValue = value; |
||
| 1904 | }; |
||
| 1905 | return { |
||
| 1906 | get: get, |
||
| 1907 | getOption: getOption, |
||
| 1908 | set: set |
||
| 1909 | }; |
||
| 1910 | }; |
||
| 1911 | |||
| 637 | daniel-mar | 1912 | var api$2 = NodeValue(isText, 'text'); |
| 1913 | var get$9 = function (element) { |
||
| 1914 | return api$2.get(element); |
||
| 597 | daniel-mar | 1915 | }; |
| 1916 | var getOption = function (element) { |
||
| 637 | daniel-mar | 1917 | return api$2.getOption(element); |
| 597 | daniel-mar | 1918 | }; |
| 637 | daniel-mar | 1919 | var set = function (element, value) { |
| 1920 | return api$2.set(element, value); |
||
| 597 | daniel-mar | 1921 | }; |
| 1922 | |||
| 1923 | var TagBoundaries = [ |
||
| 1924 | 'body', |
||
| 1925 | 'p', |
||
| 1926 | 'div', |
||
| 1927 | 'article', |
||
| 1928 | 'aside', |
||
| 1929 | 'figcaption', |
||
| 1930 | 'figure', |
||
| 1931 | 'footer', |
||
| 1932 | 'header', |
||
| 1933 | 'nav', |
||
| 1934 | 'section', |
||
| 1935 | 'ol', |
||
| 1936 | 'ul', |
||
| 1937 | 'li', |
||
| 1938 | 'table', |
||
| 1939 | 'thead', |
||
| 1940 | 'tbody', |
||
| 1941 | 'tfoot', |
||
| 1942 | 'caption', |
||
| 1943 | 'tr', |
||
| 1944 | 'td', |
||
| 1945 | 'th', |
||
| 1946 | 'h1', |
||
| 1947 | 'h2', |
||
| 1948 | 'h3', |
||
| 1949 | 'h4', |
||
| 1950 | 'h5', |
||
| 1951 | 'h6', |
||
| 1952 | 'blockquote', |
||
| 1953 | 'pre', |
||
| 1954 | 'address' |
||
| 1955 | ]; |
||
| 1956 | |||
| 1957 | function DomUniverse () { |
||
| 637 | daniel-mar | 1958 | var clone = function (element) { |
| 597 | daniel-mar | 1959 | return SugarElement.fromDom(element.dom.cloneNode(false)); |
| 1960 | }; |
||
| 1961 | var document = function (element) { |
||
| 1962 | return documentOrOwner(element).dom; |
||
| 1963 | }; |
||
| 1964 | var isBoundary = function (element) { |
||
| 1965 | if (!isElement(element)) { |
||
| 1966 | return false; |
||
| 1967 | } |
||
| 1968 | if (name(element) === 'body') { |
||
| 1969 | return true; |
||
| 1970 | } |
||
| 637 | daniel-mar | 1971 | return contains$2(TagBoundaries, name(element)); |
| 597 | daniel-mar | 1972 | }; |
| 1973 | var isEmptyTag = function (element) { |
||
| 1974 | if (!isElement(element)) { |
||
| 1975 | return false; |
||
| 1976 | } |
||
| 637 | daniel-mar | 1977 | return contains$2([ |
| 597 | daniel-mar | 1978 | 'br', |
| 1979 | 'img', |
||
| 1980 | 'hr', |
||
| 1981 | 'input' |
||
| 1982 | ], name(element)); |
||
| 1983 | }; |
||
| 1984 | var isNonEditable = function (element) { |
||
| 637 | daniel-mar | 1985 | return isElement(element) && get$b(element, 'contenteditable') === 'false'; |
| 597 | daniel-mar | 1986 | }; |
| 1987 | var comparePosition = function (element, other) { |
||
| 1988 | return element.dom.compareDocumentPosition(other.dom); |
||
| 1989 | }; |
||
| 1990 | var copyAttributesTo = function (source, destination) { |
||
| 637 | daniel-mar | 1991 | var as = clone$2(source); |
| 1992 | setAll$1(destination, as); |
||
| 597 | daniel-mar | 1993 | }; |
| 1994 | var isSpecial = function (element) { |
||
| 1995 | var tag = name(element); |
||
| 637 | daniel-mar | 1996 | return contains$2([ |
| 597 | daniel-mar | 1997 | 'script', |
| 1998 | 'noscript', |
||
| 1999 | 'iframe', |
||
| 2000 | 'noframes', |
||
| 2001 | 'noembed', |
||
| 2002 | 'title', |
||
| 2003 | 'style', |
||
| 2004 | 'textarea', |
||
| 2005 | 'xmp' |
||
| 2006 | ], tag); |
||
| 2007 | }; |
||
| 637 | daniel-mar | 2008 | var getLanguage = function (element) { |
| 2009 | return isElement(element) ? getOpt(element, 'lang') : Optional.none(); |
||
| 2010 | }; |
||
| 597 | daniel-mar | 2011 | return { |
| 2012 | up: constant({ |
||
| 2013 | selector: ancestor$1, |
||
| 2014 | closest: closest$1, |
||
| 637 | daniel-mar | 2015 | predicate: ancestor$2, |
| 597 | daniel-mar | 2016 | all: parents |
| 2017 | }), |
||
| 2018 | down: constant({ |
||
| 637 | daniel-mar | 2019 | selector: descendants, |
| 2020 | predicate: descendants$1 |
||
| 597 | daniel-mar | 2021 | }), |
| 2022 | styles: constant({ |
||
| 637 | daniel-mar | 2023 | get: get$a, |
| 2024 | getRaw: getRaw$2, |
||
| 597 | daniel-mar | 2025 | set: set$1, |
| 637 | daniel-mar | 2026 | remove: remove$6 |
| 597 | daniel-mar | 2027 | }), |
| 2028 | attrs: constant({ |
||
| 637 | daniel-mar | 2029 | get: get$b, |
| 2030 | set: set$2, |
||
| 2031 | remove: remove$7, |
||
| 597 | daniel-mar | 2032 | copyTo: copyAttributesTo |
| 2033 | }), |
||
| 2034 | insert: constant({ |
||
| 637 | daniel-mar | 2035 | before: before$4, |
| 2036 | after: after$5, |
||
| 2037 | afterAll: after$4, |
||
| 2038 | append: append$1, |
||
| 2039 | appendAll: append, |
||
| 597 | daniel-mar | 2040 | prepend: prepend, |
| 2041 | wrap: wrap |
||
| 2042 | }), |
||
| 2043 | remove: constant({ |
||
| 2044 | unwrap: unwrap, |
||
| 637 | daniel-mar | 2045 | remove: remove$5 |
| 597 | daniel-mar | 2046 | }), |
| 2047 | create: constant({ |
||
| 2048 | nu: SugarElement.fromTag, |
||
| 637 | daniel-mar | 2049 | clone: clone, |
| 597 | daniel-mar | 2050 | text: SugarElement.fromText |
| 2051 | }), |
||
| 2052 | query: constant({ |
||
| 2053 | comparePosition: comparePosition, |
||
| 2054 | prevSibling: prevSibling, |
||
| 2055 | nextSibling: nextSibling |
||
| 2056 | }), |
||
| 2057 | property: constant({ |
||
| 637 | daniel-mar | 2058 | children: children$3, |
| 597 | daniel-mar | 2059 | name: name, |
| 2060 | parent: parent, |
||
| 2061 | document: document, |
||
| 2062 | isText: isText, |
||
| 2063 | isComment: isComment, |
||
| 2064 | isElement: isElement, |
||
| 2065 | isSpecial: isSpecial, |
||
| 637 | daniel-mar | 2066 | getLanguage: getLanguage, |
| 2067 | getText: get$9, |
||
| 2068 | setText: set, |
||
| 597 | daniel-mar | 2069 | isBoundary: isBoundary, |
| 2070 | isEmptyTag: isEmptyTag, |
||
| 2071 | isNonEditable: isNonEditable |
||
| 2072 | }), |
||
| 2073 | eq: eq$1, |
||
| 2074 | is: is$1 |
||
| 2075 | }; |
||
| 2076 | } |
||
| 2077 | |||
| 637 | daniel-mar | 2078 | var all = function (universe, look, elements, f) { |
| 597 | daniel-mar | 2079 | var head = elements[0]; |
| 2080 | var tail = elements.slice(1); |
||
| 2081 | return f(universe, look, head, tail); |
||
| 2082 | }; |
||
| 2083 | var oneAll = function (universe, look, elements) { |
||
| 637 | daniel-mar | 2084 | return elements.length > 0 ? all(universe, look, elements, unsafeOne) : Optional.none(); |
| 597 | daniel-mar | 2085 | }; |
| 2086 | var unsafeOne = function (universe, look, head, tail) { |
||
| 2087 | var start = look(universe, head); |
||
| 2088 | return foldr(tail, function (b, a) { |
||
| 2089 | var current = look(universe, a); |
||
| 2090 | return commonElement(universe, b, current); |
||
| 2091 | }, start); |
||
| 2092 | }; |
||
| 2093 | var commonElement = function (universe, start, end) { |
||
| 2094 | return start.bind(function (s) { |
||
| 2095 | return end.filter(curry(universe.eq, s)); |
||
| 2096 | }); |
||
| 2097 | }; |
||
| 2098 | |||
| 637 | daniel-mar | 2099 | var eq = function (universe, item) { |
| 597 | daniel-mar | 2100 | return curry(universe.eq, item); |
| 2101 | }; |
||
| 2102 | var ancestors$2 = function (universe, start, end, isRoot) { |
||
| 2103 | if (isRoot === void 0) { |
||
| 2104 | isRoot = never; |
||
| 2105 | } |
||
| 2106 | var ps1 = [start].concat(universe.up().all(start)); |
||
| 2107 | var ps2 = [end].concat(universe.up().all(end)); |
||
| 2108 | var prune = function (path) { |
||
| 2109 | var index = findIndex(path, isRoot); |
||
| 2110 | return index.fold(function () { |
||
| 2111 | return path; |
||
| 2112 | }, function (ind) { |
||
| 2113 | return path.slice(0, ind + 1); |
||
| 2114 | }); |
||
| 2115 | }; |
||
| 2116 | var pruned1 = prune(ps1); |
||
| 2117 | var pruned2 = prune(ps2); |
||
| 637 | daniel-mar | 2118 | var shared = find$1(pruned1, function (x) { |
| 2119 | return exists(pruned2, eq(universe, x)); |
||
| 597 | daniel-mar | 2120 | }); |
| 2121 | return { |
||
| 2122 | firstpath: pruned1, |
||
| 2123 | secondpath: pruned2, |
||
| 2124 | shared: shared |
||
| 2125 | }; |
||
| 2126 | }; |
||
| 2127 | |||
| 637 | daniel-mar | 2128 | var sharedOne$1 = oneAll; |
| 2129 | var ancestors$1 = ancestors$2; |
||
| 597 | daniel-mar | 2130 | |
| 637 | daniel-mar | 2131 | var universe$3 = DomUniverse(); |
| 2132 | var sharedOne = function (look, elements) { |
||
| 2133 | return sharedOne$1(universe$3, function (_universe, element) { |
||
| 597 | daniel-mar | 2134 | return look(element); |
| 2135 | }, elements); |
||
| 2136 | }; |
||
| 637 | daniel-mar | 2137 | var ancestors = function (start, finish, isRoot) { |
| 2138 | return ancestors$1(universe$3, start, finish, isRoot); |
||
| 597 | daniel-mar | 2139 | }; |
| 2140 | |||
| 2141 | var lookupTable = function (container) { |
||
| 2142 | return ancestor$1(container, 'table'); |
||
| 2143 | }; |
||
| 2144 | var identify = function (start, finish, isRoot) { |
||
| 2145 | var getIsRoot = function (rootTable) { |
||
| 2146 | return function (element) { |
||
| 2147 | return isRoot !== undefined && isRoot(element) || eq$1(element, rootTable); |
||
| 2148 | }; |
||
| 2149 | }; |
||
| 2150 | if (eq$1(start, finish)) { |
||
| 2151 | return Optional.some({ |
||
| 2152 | boxes: Optional.some([start]), |
||
| 2153 | start: start, |
||
| 2154 | finish: finish |
||
| 2155 | }); |
||
| 2156 | } else { |
||
| 2157 | return lookupTable(start).bind(function (startTable) { |
||
| 2158 | return lookupTable(finish).bind(function (finishTable) { |
||
| 2159 | if (eq$1(startTable, finishTable)) { |
||
| 2160 | return Optional.some({ |
||
| 637 | daniel-mar | 2161 | boxes: intercepts(startTable, start, finish), |
| 597 | daniel-mar | 2162 | start: start, |
| 2163 | finish: finish |
||
| 2164 | }); |
||
| 637 | daniel-mar | 2165 | } else if (contains(startTable, finishTable)) { |
| 2166 | var ancestorCells = ancestors$3(finish, 'td,th', getIsRoot(startTable)); |
||
| 597 | daniel-mar | 2167 | var finishCell = ancestorCells.length > 0 ? ancestorCells[ancestorCells.length - 1] : finish; |
| 2168 | return Optional.some({ |
||
| 2169 | boxes: nestedIntercepts(startTable, start, startTable, finish, finishTable), |
||
| 2170 | start: start, |
||
| 2171 | finish: finishCell |
||
| 2172 | }); |
||
| 637 | daniel-mar | 2173 | } else if (contains(finishTable, startTable)) { |
| 2174 | var ancestorCells = ancestors$3(start, 'td,th', getIsRoot(finishTable)); |
||
| 597 | daniel-mar | 2175 | var startCell = ancestorCells.length > 0 ? ancestorCells[ancestorCells.length - 1] : start; |
| 2176 | return Optional.some({ |
||
| 2177 | boxes: nestedIntercepts(finishTable, start, startTable, finish, finishTable), |
||
| 2178 | start: start, |
||
| 2179 | finish: startCell |
||
| 2180 | }); |
||
| 2181 | } else { |
||
| 637 | daniel-mar | 2182 | return ancestors(start, finish).shared.bind(function (lca) { |
| 597 | daniel-mar | 2183 | return closest$1(lca, 'table', isRoot).bind(function (lcaTable) { |
| 637 | daniel-mar | 2184 | var finishAncestorCells = ancestors$3(finish, 'td,th', getIsRoot(lcaTable)); |
| 597 | daniel-mar | 2185 | var finishCell = finishAncestorCells.length > 0 ? finishAncestorCells[finishAncestorCells.length - 1] : finish; |
| 637 | daniel-mar | 2186 | var startAncestorCells = ancestors$3(start, 'td,th', getIsRoot(lcaTable)); |
| 597 | daniel-mar | 2187 | var startCell = startAncestorCells.length > 0 ? startAncestorCells[startAncestorCells.length - 1] : start; |
| 2188 | return Optional.some({ |
||
| 2189 | boxes: nestedIntercepts(lcaTable, start, startTable, finish, finishTable), |
||
| 2190 | start: startCell, |
||
| 2191 | finish: finishCell |
||
| 2192 | }); |
||
| 2193 | }); |
||
| 2194 | }); |
||
| 2195 | } |
||
| 2196 | }); |
||
| 2197 | }); |
||
| 2198 | } |
||
| 2199 | }; |
||
| 637 | daniel-mar | 2200 | var retrieve$1 = function (container, selector) { |
| 2201 | var sels = descendants(container, selector); |
||
| 597 | daniel-mar | 2202 | return sels.length > 0 ? Optional.some(sels) : Optional.none(); |
| 2203 | }; |
||
| 2204 | var getLast = function (boxes, lastSelectedSelector) { |
||
| 637 | daniel-mar | 2205 | return find$1(boxes, function (box) { |
| 2206 | return is$2(box, lastSelectedSelector); |
||
| 597 | daniel-mar | 2207 | }); |
| 2208 | }; |
||
| 2209 | var getEdges = function (container, firstSelectedSelector, lastSelectedSelector) { |
||
| 637 | daniel-mar | 2210 | return descendant(container, firstSelectedSelector).bind(function (first) { |
| 2211 | return descendant(container, lastSelectedSelector).bind(function (last) { |
||
| 2212 | return sharedOne(lookupTable, [ |
||
| 597 | daniel-mar | 2213 | first, |
| 2214 | last |
||
| 2215 | ]).map(function (table) { |
||
| 2216 | return { |
||
| 2217 | first: first, |
||
| 2218 | last: last, |
||
| 2219 | table: table |
||
| 2220 | }; |
||
| 2221 | }); |
||
| 2222 | }); |
||
| 2223 | }); |
||
| 2224 | }; |
||
| 2225 | var expandTo = function (finish, firstSelectedSelector) { |
||
| 2226 | return ancestor$1(finish, 'table').bind(function (table) { |
||
| 637 | daniel-mar | 2227 | return descendant(table, firstSelectedSelector).bind(function (start) { |
| 597 | daniel-mar | 2228 | return identify(start, finish).bind(function (identified) { |
| 2229 | return identified.boxes.map(function (boxes) { |
||
| 2230 | return { |
||
| 2231 | boxes: boxes, |
||
| 2232 | start: identified.start, |
||
| 2233 | finish: identified.finish |
||
| 2234 | }; |
||
| 2235 | }); |
||
| 2236 | }); |
||
| 2237 | }); |
||
| 2238 | }); |
||
| 2239 | }; |
||
| 2240 | var shiftSelection = function (boxes, deltaRow, deltaColumn, firstSelectedSelector, lastSelectedSelector) { |
||
| 2241 | return getLast(boxes, lastSelectedSelector).bind(function (last) { |
||
| 637 | daniel-mar | 2242 | return moveBy(last, deltaRow, deltaColumn).bind(function (finish) { |
| 597 | daniel-mar | 2243 | return expandTo(finish, firstSelectedSelector); |
| 2244 | }); |
||
| 2245 | }); |
||
| 2246 | }; |
||
| 2247 | |||
| 637 | daniel-mar | 2248 | var retrieve = function (container, selector) { |
| 2249 | return retrieve$1(container, selector); |
||
| 597 | daniel-mar | 2250 | }; |
| 2251 | var retrieveBox = function (container, firstSelectedSelector, lastSelectedSelector) { |
||
| 2252 | return getEdges(container, firstSelectedSelector, lastSelectedSelector).bind(function (edges) { |
||
| 2253 | var isRoot = function (ancestor) { |
||
| 2254 | return eq$1(container, ancestor); |
||
| 2255 | }; |
||
| 2256 | var sectionSelector = 'thead,tfoot,tbody,table'; |
||
| 2257 | var firstAncestor = ancestor$1(edges.first, sectionSelector, isRoot); |
||
| 2258 | var lastAncestor = ancestor$1(edges.last, sectionSelector, isRoot); |
||
| 2259 | return firstAncestor.bind(function (fA) { |
||
| 2260 | return lastAncestor.bind(function (lA) { |
||
| 637 | daniel-mar | 2261 | return eq$1(fA, lA) ? getBox(edges.table, edges.first, edges.last) : Optional.none(); |
| 597 | daniel-mar | 2262 | }); |
| 2263 | }); |
||
| 2264 | }); |
||
| 2265 | }; |
||
| 2266 | |||
| 637 | daniel-mar | 2267 | var generate = function (cases) { |
| 597 | daniel-mar | 2268 | if (!isArray(cases)) { |
| 2269 | throw new Error('cases must be an array'); |
||
| 2270 | } |
||
| 2271 | if (cases.length === 0) { |
||
| 2272 | throw new Error('there must be at least one case'); |
||
| 2273 | } |
||
| 2274 | var constructors = []; |
||
| 2275 | var adt = {}; |
||
| 637 | daniel-mar | 2276 | each$2(cases, function (acase, count) { |
| 597 | daniel-mar | 2277 | var keys$1 = keys(acase); |
| 2278 | if (keys$1.length !== 1) { |
||
| 2279 | throw new Error('one and only one name per case'); |
||
| 2280 | } |
||
| 2281 | var key = keys$1[0]; |
||
| 2282 | var value = acase[key]; |
||
| 2283 | if (adt[key] !== undefined) { |
||
| 2284 | throw new Error('duplicate key detected:' + key); |
||
| 2285 | } else if (key === 'cata') { |
||
| 2286 | throw new Error('cannot have a case named cata (sorry)'); |
||
| 2287 | } else if (!isArray(value)) { |
||
| 2288 | throw new Error('case arguments must be an array'); |
||
| 2289 | } |
||
| 2290 | constructors.push(key); |
||
| 2291 | adt[key] = function () { |
||
| 2292 | var args = []; |
||
| 2293 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 2294 | args[_i] = arguments[_i]; |
||
| 2295 | } |
||
| 2296 | var argLength = args.length; |
||
| 2297 | if (argLength !== value.length) { |
||
| 2298 | throw new Error('Wrong number of arguments to case ' + key + '. Expected ' + value.length + ' (' + value + '), got ' + argLength); |
||
| 2299 | } |
||
| 2300 | var match = function (branches) { |
||
| 2301 | var branchKeys = keys(branches); |
||
| 2302 | if (constructors.length !== branchKeys.length) { |
||
| 2303 | throw new Error('Wrong number of arguments to match. Expected: ' + constructors.join(',') + '\nActual: ' + branchKeys.join(',')); |
||
| 2304 | } |
||
| 2305 | var allReqd = forall(constructors, function (reqKey) { |
||
| 637 | daniel-mar | 2306 | return contains$2(branchKeys, reqKey); |
| 597 | daniel-mar | 2307 | }); |
| 2308 | if (!allReqd) { |
||
| 2309 | throw new Error('Not all branches were specified when using match. Specified: ' + branchKeys.join(', ') + '\nRequired: ' + constructors.join(', ')); |
||
| 2310 | } |
||
| 2311 | return branches[key].apply(null, args); |
||
| 2312 | }; |
||
| 2313 | return { |
||
| 2314 | fold: function () { |
||
| 2315 | var foldArgs = []; |
||
| 2316 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 2317 | foldArgs[_i] = arguments[_i]; |
||
| 2318 | } |
||
| 2319 | if (foldArgs.length !== cases.length) { |
||
| 2320 | throw new Error('Wrong number of arguments to fold. Expected ' + cases.length + ', got ' + foldArgs.length); |
||
| 2321 | } |
||
| 2322 | var target = foldArgs[count]; |
||
| 2323 | return target.apply(null, args); |
||
| 2324 | }, |
||
| 2325 | match: match, |
||
| 2326 | log: function (label) { |
||
| 2327 | console.log(label, { |
||
| 2328 | constructors: constructors, |
||
| 2329 | constructor: key, |
||
| 2330 | params: args |
||
| 2331 | }); |
||
| 2332 | } |
||
| 2333 | }; |
||
| 2334 | }; |
||
| 2335 | }); |
||
| 2336 | return adt; |
||
| 2337 | }; |
||
| 637 | daniel-mar | 2338 | var Adt = { generate: generate }; |
| 597 | daniel-mar | 2339 | |
| 637 | daniel-mar | 2340 | var type = Adt.generate([ |
| 597 | daniel-mar | 2341 | { none: [] }, |
| 2342 | { multiple: ['elements'] }, |
||
| 2343 | { single: ['element'] } |
||
| 2344 | ]); |
||
| 637 | daniel-mar | 2345 | var cata$2 = function (subject, onNone, onMultiple, onSingle) { |
| 597 | daniel-mar | 2346 | return subject.fold(onNone, onMultiple, onSingle); |
| 2347 | }; |
||
| 637 | daniel-mar | 2348 | var none$1 = type.none; |
| 2349 | var multiple = type.multiple; |
||
| 2350 | var single = type.single; |
||
| 597 | daniel-mar | 2351 | |
| 2352 | var Selections = function (lazyRoot, getStart, selectedSelector) { |
||
| 2353 | var get = function () { |
||
| 637 | daniel-mar | 2354 | return retrieve(lazyRoot(), selectedSelector).fold(function () { |
| 2355 | return getStart().fold(none$1, single); |
||
| 597 | daniel-mar | 2356 | }, function (cells) { |
| 2357 | return multiple(cells); |
||
| 2358 | }); |
||
| 2359 | }; |
||
| 2360 | return { get: get }; |
||
| 2361 | }; |
||
| 2362 | |||
| 637 | daniel-mar | 2363 | var global$3 = tinymce.util.Tools.resolve('tinymce.PluginManager'); |
| 597 | daniel-mar | 2364 | |
| 637 | daniel-mar | 2365 | var clone = function (original, isDeep) { |
| 597 | daniel-mar | 2366 | return SugarElement.fromDom(original.dom.cloneNode(isDeep)); |
| 2367 | }; |
||
| 2368 | var shallow = function (original) { |
||
| 637 | daniel-mar | 2369 | return clone(original, false); |
| 597 | daniel-mar | 2370 | }; |
| 2371 | var deep = function (original) { |
||
| 637 | daniel-mar | 2372 | return clone(original, true); |
| 597 | daniel-mar | 2373 | }; |
| 2374 | var shallowAs = function (original, tag) { |
||
| 2375 | var nu = SugarElement.fromTag(tag); |
||
| 637 | daniel-mar | 2376 | var attributes = clone$2(original); |
| 2377 | setAll$1(nu, attributes); |
||
| 597 | daniel-mar | 2378 | return nu; |
| 2379 | }; |
||
| 2380 | var copy$1 = function (original, tag) { |
||
| 2381 | var nu = shallowAs(original, tag); |
||
| 637 | daniel-mar | 2382 | var cloneChildren = children$3(deep(original)); |
| 2383 | append(nu, cloneChildren); |
||
| 597 | daniel-mar | 2384 | return nu; |
| 2385 | }; |
||
| 637 | daniel-mar | 2386 | var mutate$1 = function (original, tag) { |
| 2387 | var nu = shallowAs(original, tag); |
||
| 2388 | before$4(original, nu); |
||
| 2389 | var children = children$3(original); |
||
| 2390 | append(nu, children); |
||
| 2391 | remove$5(original); |
||
| 2392 | return nu; |
||
| 597 | daniel-mar | 2393 | }; |
| 2394 | |||
| 2395 | var Dimension = function (name, getOffset) { |
||
| 2396 | var set = function (element, h) { |
||
| 2397 | if (!isNumber(h) && !h.match(/^[0-9]+$/)) { |
||
| 2398 | throw new Error(name + '.set accepts only positive integer values. Value was ' + h); |
||
| 2399 | } |
||
| 2400 | var dom = element.dom; |
||
| 637 | daniel-mar | 2401 | if (isSupported(dom)) { |
| 597 | daniel-mar | 2402 | dom.style[name] = h + 'px'; |
| 2403 | } |
||
| 2404 | }; |
||
| 2405 | var get = function (element) { |
||
| 2406 | var r = getOffset(element); |
||
| 2407 | if (r <= 0 || r === null) { |
||
| 637 | daniel-mar | 2408 | var css = get$a(element, name); |
| 597 | daniel-mar | 2409 | return parseFloat(css) || 0; |
| 2410 | } |
||
| 2411 | return r; |
||
| 2412 | }; |
||
| 2413 | var getOuter = get; |
||
| 2414 | var aggregate = function (element, properties) { |
||
| 2415 | return foldl(properties, function (acc, property) { |
||
| 637 | daniel-mar | 2416 | var val = get$a(element, property); |
| 597 | daniel-mar | 2417 | var value = val === undefined ? 0 : parseInt(val, 10); |
| 2418 | return isNaN(value) ? acc : acc + value; |
||
| 2419 | }, 0); |
||
| 2420 | }; |
||
| 2421 | var max = function (element, value, properties) { |
||
| 2422 | var cumulativeInclusions = aggregate(element, properties); |
||
| 2423 | var absoluteMax = value > cumulativeInclusions ? value - cumulativeInclusions : 0; |
||
| 2424 | return absoluteMax; |
||
| 2425 | }; |
||
| 2426 | return { |
||
| 2427 | set: set, |
||
| 2428 | get: get, |
||
| 2429 | getOuter: getOuter, |
||
| 2430 | aggregate: aggregate, |
||
| 2431 | max: max |
||
| 2432 | }; |
||
| 2433 | }; |
||
| 2434 | |||
| 679 | daniel-mar | 2435 | var needManualCalc = function () { |
| 2436 | var browser = detect$3().browser; |
||
| 2437 | return browser.isIE() || browser.isEdge(); |
||
| 2438 | }; |
||
| 2439 | var toNumber = function (px, fallback) { |
||
| 2440 | return toFloat(px).getOr(fallback); |
||
| 2441 | }; |
||
| 2442 | var getProp = function (element, name, fallback) { |
||
| 2443 | return toNumber(get$a(element, name), fallback); |
||
| 2444 | }; |
||
| 2445 | var getBoxSizing = function (element) { |
||
| 2446 | return get$a(element, 'box-sizing'); |
||
| 2447 | }; |
||
| 2448 | var calcContentBoxSize = function (element, size, upper, lower) { |
||
| 2449 | var paddingUpper = getProp(element, 'padding-' + upper, 0); |
||
| 2450 | var paddingLower = getProp(element, 'padding-' + lower, 0); |
||
| 2451 | var borderUpper = getProp(element, 'border-' + upper + '-width', 0); |
||
| 2452 | var borderLower = getProp(element, 'border-' + lower + '-width', 0); |
||
| 2453 | return size - paddingUpper - paddingLower - borderUpper - borderLower; |
||
| 2454 | }; |
||
| 2455 | var getCalculatedHeight = function (element, boxSizing) { |
||
| 2456 | var dom = element.dom; |
||
| 2457 | var height = dom.getBoundingClientRect().height || dom.offsetHeight; |
||
| 2458 | return boxSizing === 'border-box' ? height : calcContentBoxSize(element, height, 'top', 'bottom'); |
||
| 2459 | }; |
||
| 2460 | var getCalculatedWidth = function (element, boxSizing) { |
||
| 2461 | var dom = element.dom; |
||
| 2462 | var width = dom.getBoundingClientRect().width || dom.offsetWidth; |
||
| 2463 | return boxSizing === 'border-box' ? width : calcContentBoxSize(element, width, 'left', 'right'); |
||
| 2464 | }; |
||
| 2465 | var getHeight$1 = function (element) { |
||
| 2466 | return needManualCalc() ? getCalculatedHeight(element, getBoxSizing(element)) : getProp(element, 'height', element.dom.offsetHeight); |
||
| 2467 | }; |
||
| 2468 | var getWidth = function (element) { |
||
| 2469 | return needManualCalc() ? getCalculatedWidth(element, getBoxSizing(element)) : getProp(element, 'width', element.dom.offsetWidth); |
||
| 2470 | }; |
||
| 2471 | var getInnerWidth = function (element) { |
||
| 2472 | return getCalculatedWidth(element, 'content-box'); |
||
| 2473 | }; |
||
| 2474 | |||
| 597 | daniel-mar | 2475 | var api$1 = Dimension('width', function (element) { |
| 2476 | return element.dom.offsetWidth; |
||
| 2477 | }); |
||
| 637 | daniel-mar | 2478 | var get$8 = function (element) { |
| 597 | daniel-mar | 2479 | return api$1.get(element); |
| 2480 | }; |
||
| 637 | daniel-mar | 2481 | var getOuter$2 = function (element) { |
| 597 | daniel-mar | 2482 | return api$1.getOuter(element); |
| 2483 | }; |
||
| 679 | daniel-mar | 2484 | var getInner = getInnerWidth; |
| 2485 | var getRuntime$1 = getWidth; |
||
| 597 | daniel-mar | 2486 | |
| 637 | daniel-mar | 2487 | var columns = function (warehouse, isValidCell) { |
| 597 | daniel-mar | 2488 | if (isValidCell === void 0) { |
| 2489 | isValidCell = always; |
||
| 2490 | } |
||
| 2491 | var grid = warehouse.grid; |
||
| 637 | daniel-mar | 2492 | var cols = range$1(grid.columns, identity); |
| 2493 | var rowsArr = range$1(grid.rows, identity); |
||
| 2494 | return map$1(cols, function (col) { |
||
| 597 | daniel-mar | 2495 | var getBlock = function () { |
| 637 | daniel-mar | 2496 | return bind$2(rowsArr, function (r) { |
| 597 | daniel-mar | 2497 | return Warehouse.getAt(warehouse, r, col).filter(function (detail) { |
| 2498 | return detail.column === col; |
||
| 2499 | }).toArray(); |
||
| 2500 | }); |
||
| 2501 | }; |
||
| 2502 | var isValid = function (detail) { |
||
| 2503 | return detail.colspan === 1 && isValidCell(detail.element); |
||
| 2504 | }; |
||
| 2505 | var getFallback = function () { |
||
| 2506 | return Warehouse.getAt(warehouse, 0, col); |
||
| 2507 | }; |
||
| 2508 | return decide(getBlock, isValid, getFallback); |
||
| 2509 | }); |
||
| 2510 | }; |
||
| 2511 | var decide = function (getBlock, isValid, getFallback) { |
||
| 2512 | var inBlock = getBlock(); |
||
| 637 | daniel-mar | 2513 | var validInBlock = find$1(inBlock, isValid); |
| 597 | daniel-mar | 2514 | var detailOption = validInBlock.orThunk(function () { |
| 2515 | return Optional.from(inBlock[0]).orThunk(getFallback); |
||
| 2516 | }); |
||
| 2517 | return detailOption.map(function (detail) { |
||
| 2518 | return detail.element; |
||
| 2519 | }); |
||
| 2520 | }; |
||
| 637 | daniel-mar | 2521 | var rows = function (warehouse) { |
| 597 | daniel-mar | 2522 | var grid = warehouse.grid; |
| 637 | daniel-mar | 2523 | var rowsArr = range$1(grid.rows, identity); |
| 2524 | var cols = range$1(grid.columns, identity); |
||
| 2525 | return map$1(rowsArr, function (row) { |
||
| 597 | daniel-mar | 2526 | var getBlock = function () { |
| 637 | daniel-mar | 2527 | return bind$2(cols, function (c) { |
| 597 | daniel-mar | 2528 | return Warehouse.getAt(warehouse, row, c).filter(function (detail) { |
| 2529 | return detail.row === row; |
||
| 2530 | }).fold(constant([]), function (detail) { |
||
| 2531 | return [detail]; |
||
| 2532 | }); |
||
| 2533 | }); |
||
| 2534 | }; |
||
| 2535 | var isSingle = function (detail) { |
||
| 2536 | return detail.rowspan === 1; |
||
| 2537 | }; |
||
| 2538 | var getFallback = function () { |
||
| 2539 | return Warehouse.getAt(warehouse, row, 0); |
||
| 2540 | }; |
||
| 2541 | return decide(getBlock, isSingle, getFallback); |
||
| 2542 | }); |
||
| 2543 | }; |
||
| 2544 | |||
| 2545 | var deduce = function (xs, index) { |
||
| 2546 | if (index < 0 || index >= xs.length - 1) { |
||
| 2547 | return Optional.none(); |
||
| 2548 | } |
||
| 2549 | var current = xs[index].fold(function () { |
||
| 2550 | var rest = reverse(xs.slice(0, index)); |
||
| 2551 | return findMap(rest, function (a, i) { |
||
| 2552 | return a.map(function (aa) { |
||
| 2553 | return { |
||
| 2554 | value: aa, |
||
| 2555 | delta: i + 1 |
||
| 2556 | }; |
||
| 2557 | }); |
||
| 2558 | }); |
||
| 2559 | }, function (c) { |
||
| 2560 | return Optional.some({ |
||
| 2561 | value: c, |
||
| 2562 | delta: 0 |
||
| 2563 | }); |
||
| 2564 | }); |
||
| 2565 | var next = xs[index + 1].fold(function () { |
||
| 2566 | var rest = xs.slice(index + 1); |
||
| 2567 | return findMap(rest, function (a, i) { |
||
| 2568 | return a.map(function (aa) { |
||
| 2569 | return { |
||
| 2570 | value: aa, |
||
| 2571 | delta: i + 1 |
||
| 2572 | }; |
||
| 2573 | }); |
||
| 2574 | }); |
||
| 2575 | }, function (n) { |
||
| 2576 | return Optional.some({ |
||
| 2577 | value: n, |
||
| 2578 | delta: 1 |
||
| 2579 | }); |
||
| 2580 | }); |
||
| 2581 | return current.bind(function (c) { |
||
| 2582 | return next.map(function (n) { |
||
| 2583 | var extras = n.delta + c.delta; |
||
| 2584 | return Math.abs(n.value - c.value) / extras; |
||
| 2585 | }); |
||
| 2586 | }); |
||
| 2587 | }; |
||
| 2588 | |||
| 2589 | var onDirection = function (isLtr, isRtl) { |
||
| 2590 | return function (element) { |
||
| 2591 | return getDirection(element) === 'rtl' ? isRtl : isLtr; |
||
| 2592 | }; |
||
| 2593 | }; |
||
| 2594 | var getDirection = function (element) { |
||
| 637 | daniel-mar | 2595 | return get$a(element, 'direction') === 'rtl' ? 'rtl' : 'ltr'; |
| 597 | daniel-mar | 2596 | }; |
| 2597 | |||
| 637 | daniel-mar | 2598 | var api = Dimension('height', function (element) { |
| 597 | daniel-mar | 2599 | var dom = element.dom; |
| 2600 | return inBody(element) ? dom.getBoundingClientRect().height : dom.offsetHeight; |
||
| 2601 | }); |
||
| 637 | daniel-mar | 2602 | var get$7 = function (element) { |
| 2603 | return api.get(element); |
||
| 597 | daniel-mar | 2604 | }; |
| 2605 | var getOuter$1 = function (element) { |
||
| 637 | daniel-mar | 2606 | return api.getOuter(element); |
| 597 | daniel-mar | 2607 | }; |
| 679 | daniel-mar | 2608 | var getRuntime = getHeight$1; |
| 597 | daniel-mar | 2609 | |
| 2610 | var r = function (left, top) { |
||
| 2611 | var translate = function (x, y) { |
||
| 2612 | return r(left + x, top + y); |
||
| 2613 | }; |
||
| 2614 | return { |
||
| 2615 | left: left, |
||
| 2616 | top: top, |
||
| 2617 | translate: translate |
||
| 2618 | }; |
||
| 2619 | }; |
||
| 2620 | var SugarPosition = r; |
||
| 2621 | |||
| 2622 | var boxPosition = function (dom) { |
||
| 2623 | var box = dom.getBoundingClientRect(); |
||
| 2624 | return SugarPosition(box.left, box.top); |
||
| 2625 | }; |
||
| 2626 | var firstDefinedOrZero = function (a, b) { |
||
| 2627 | if (a !== undefined) { |
||
| 2628 | return a; |
||
| 2629 | } else { |
||
| 2630 | return b !== undefined ? b : 0; |
||
| 2631 | } |
||
| 2632 | }; |
||
| 2633 | var absolute = function (element) { |
||
| 2634 | var doc = element.dom.ownerDocument; |
||
| 2635 | var body = doc.body; |
||
| 2636 | var win = doc.defaultView; |
||
| 2637 | var html = doc.documentElement; |
||
| 2638 | if (body === element.dom) { |
||
| 2639 | return SugarPosition(body.offsetLeft, body.offsetTop); |
||
| 2640 | } |
||
| 2641 | var scrollTop = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageYOffset, html.scrollTop); |
||
| 2642 | var scrollLeft = firstDefinedOrZero(win === null || win === void 0 ? void 0 : win.pageXOffset, html.scrollLeft); |
||
| 2643 | var clientTop = firstDefinedOrZero(html.clientTop, body.clientTop); |
||
| 2644 | var clientLeft = firstDefinedOrZero(html.clientLeft, body.clientLeft); |
||
| 2645 | return viewport(element).translate(scrollLeft - clientLeft, scrollTop - clientTop); |
||
| 2646 | }; |
||
| 2647 | var viewport = function (element) { |
||
| 2648 | var dom = element.dom; |
||
| 2649 | var doc = dom.ownerDocument; |
||
| 2650 | var body = doc.body; |
||
| 2651 | if (body === dom) { |
||
| 2652 | return SugarPosition(body.offsetLeft, body.offsetTop); |
||
| 2653 | } |
||
| 2654 | if (!inBody(element)) { |
||
| 2655 | return SugarPosition(0, 0); |
||
| 2656 | } |
||
| 2657 | return boxPosition(dom); |
||
| 2658 | }; |
||
| 2659 | |||
| 2660 | var rowInfo = function (row, y) { |
||
| 2661 | return { |
||
| 2662 | row: row, |
||
| 2663 | y: y |
||
| 2664 | }; |
||
| 2665 | }; |
||
| 2666 | var colInfo = function (col, x) { |
||
| 2667 | return { |
||
| 2668 | col: col, |
||
| 2669 | x: x |
||
| 2670 | }; |
||
| 2671 | }; |
||
| 2672 | var rtlEdge = function (cell) { |
||
| 2673 | var pos = absolute(cell); |
||
| 637 | daniel-mar | 2674 | return pos.left + getOuter$2(cell); |
| 597 | daniel-mar | 2675 | }; |
| 2676 | var ltrEdge = function (cell) { |
||
| 2677 | return absolute(cell).left; |
||
| 2678 | }; |
||
| 2679 | var getLeftEdge = function (index, cell) { |
||
| 2680 | return colInfo(index, ltrEdge(cell)); |
||
| 2681 | }; |
||
| 2682 | var getRightEdge = function (index, cell) { |
||
| 2683 | return colInfo(index, rtlEdge(cell)); |
||
| 2684 | }; |
||
| 637 | daniel-mar | 2685 | var getTop$1 = function (cell) { |
| 597 | daniel-mar | 2686 | return absolute(cell).top; |
| 2687 | }; |
||
| 2688 | var getTopEdge = function (index, cell) { |
||
| 637 | daniel-mar | 2689 | return rowInfo(index, getTop$1(cell)); |
| 597 | daniel-mar | 2690 | }; |
| 2691 | var getBottomEdge = function (index, cell) { |
||
| 637 | daniel-mar | 2692 | return rowInfo(index, getTop$1(cell) + getOuter$1(cell)); |
| 597 | daniel-mar | 2693 | }; |
| 2694 | var findPositions = function (getInnerEdge, getOuterEdge, array) { |
||
| 2695 | if (array.length === 0) { |
||
| 2696 | return []; |
||
| 2697 | } |
||
| 637 | daniel-mar | 2698 | var lines = map$1(array.slice(1), function (cellOption, index) { |
| 597 | daniel-mar | 2699 | return cellOption.map(function (cell) { |
| 2700 | return getInnerEdge(index, cell); |
||
| 2701 | }); |
||
| 2702 | }); |
||
| 2703 | var lastLine = array[array.length - 1].map(function (cell) { |
||
| 2704 | return getOuterEdge(array.length - 1, cell); |
||
| 2705 | }); |
||
| 2706 | return lines.concat([lastLine]); |
||
| 2707 | }; |
||
| 2708 | var negate = function (step) { |
||
| 2709 | return -step; |
||
| 2710 | }; |
||
| 2711 | var height = { |
||
| 2712 | delta: identity, |
||
| 2713 | positions: function (optElements) { |
||
| 2714 | return findPositions(getTopEdge, getBottomEdge, optElements); |
||
| 2715 | }, |
||
| 637 | daniel-mar | 2716 | edge: getTop$1 |
| 597 | daniel-mar | 2717 | }; |
| 637 | daniel-mar | 2718 | var ltr$1 = { |
| 597 | daniel-mar | 2719 | delta: identity, |
| 2720 | edge: ltrEdge, |
||
| 2721 | positions: function (optElements) { |
||
| 2722 | return findPositions(getLeftEdge, getRightEdge, optElements); |
||
| 2723 | } |
||
| 2724 | }; |
||
| 637 | daniel-mar | 2725 | var rtl$1 = { |
| 597 | daniel-mar | 2726 | delta: negate, |
| 2727 | edge: rtlEdge, |
||
| 2728 | positions: function (optElements) { |
||
| 2729 | return findPositions(getRightEdge, getLeftEdge, optElements); |
||
| 2730 | } |
||
| 2731 | }; |
||
| 637 | daniel-mar | 2732 | var detect$2 = onDirection(ltr$1, rtl$1); |
| 597 | daniel-mar | 2733 | var width = { |
| 2734 | delta: function (amount, table) { |
||
| 637 | daniel-mar | 2735 | return detect$2(table).delta(amount, table); |
| 597 | daniel-mar | 2736 | }, |
| 2737 | positions: function (cols, table) { |
||
| 637 | daniel-mar | 2738 | return detect$2(table).positions(cols, table); |
| 597 | daniel-mar | 2739 | }, |
| 2740 | edge: function (cell) { |
||
| 637 | daniel-mar | 2741 | return detect$2(cell).edge(cell); |
| 597 | daniel-mar | 2742 | } |
| 2743 | }; |
||
| 2744 | |||
| 2745 | var units = { |
||
| 2746 | unsupportedLength: [ |
||
| 2747 | 'em', |
||
| 2748 | 'ex', |
||
| 2749 | 'cap', |
||
| 2750 | 'ch', |
||
| 2751 | 'ic', |
||
| 2752 | 'rem', |
||
| 2753 | 'lh', |
||
| 2754 | 'rlh', |
||
| 2755 | 'vw', |
||
| 2756 | 'vh', |
||
| 2757 | 'vi', |
||
| 2758 | 'vb', |
||
| 2759 | 'vmin', |
||
| 2760 | 'vmax', |
||
| 2761 | 'cm', |
||
| 2762 | 'mm', |
||
| 2763 | 'Q', |
||
| 2764 | 'in', |
||
| 2765 | 'pc', |
||
| 2766 | 'pt', |
||
| 2767 | 'px' |
||
| 2768 | ], |
||
| 2769 | fixed: [ |
||
| 2770 | 'px', |
||
| 2771 | 'pt' |
||
| 2772 | ], |
||
| 2773 | relative: ['%'], |
||
| 2774 | empty: [''] |
||
| 2775 | }; |
||
| 2776 | var pattern = function () { |
||
| 2777 | var decimalDigits = '[0-9]+'; |
||
| 2778 | var signedInteger = '[+-]?' + decimalDigits; |
||
| 2779 | var exponentPart = '[eE]' + signedInteger; |
||
| 2780 | var dot = '\\.'; |
||
| 2781 | var opt = function (input) { |
||
| 2782 | return '(?:' + input + ')?'; |
||
| 2783 | }; |
||
| 2784 | var unsignedDecimalLiteral = [ |
||
| 2785 | 'Infinity', |
||
| 2786 | decimalDigits + dot + opt(decimalDigits) + opt(exponentPart), |
||
| 2787 | dot + decimalDigits + opt(exponentPart), |
||
| 2788 | decimalDigits + opt(exponentPart) |
||
| 2789 | ].join('|'); |
||
| 2790 | var float = '[+-]?(?:' + unsignedDecimalLiteral + ')'; |
||
| 2791 | return new RegExp('^(' + float + ')(.*)$'); |
||
| 2792 | }(); |
||
| 2793 | var isUnit = function (unit, accepted) { |
||
| 2794 | return exists(accepted, function (acc) { |
||
| 2795 | return exists(units[acc], function (check) { |
||
| 2796 | return unit === check; |
||
| 2797 | }); |
||
| 2798 | }); |
||
| 2799 | }; |
||
| 2800 | var parse = function (input, accepted) { |
||
| 2801 | var match = Optional.from(pattern.exec(input)); |
||
| 2802 | return match.bind(function (array) { |
||
| 2803 | var value = Number(array[1]); |
||
| 2804 | var unitRaw = array[2]; |
||
| 2805 | if (isUnit(unitRaw, accepted)) { |
||
| 2806 | return Optional.some({ |
||
| 2807 | value: value, |
||
| 2808 | unit: unitRaw |
||
| 2809 | }); |
||
| 2810 | } else { |
||
| 2811 | return Optional.none(); |
||
| 2812 | } |
||
| 2813 | }); |
||
| 2814 | }; |
||
| 2815 | |||
| 2816 | var rPercentageBasedSizeRegex = /(\d+(\.\d+)?)%/; |
||
| 2817 | var rPixelBasedSizeRegex = /(\d+(\.\d+)?)px|em/; |
||
| 679 | daniel-mar | 2818 | var isCol$2 = isTag('col'); |
| 2819 | var getPercentSize = function (elm, outerGetter, innerGetter) { |
||
| 2820 | var relativeParent = parentElement(elm).getOrThunk(function () { |
||
| 2821 | return getBody$1(owner(elm)); |
||
| 2822 | }); |
||
| 2823 | return outerGetter(elm) / innerGetter(relativeParent) * 100; |
||
| 597 | daniel-mar | 2824 | }; |
| 2825 | var setPixelWidth = function (cell, amount) { |
||
| 2826 | set$1(cell, 'width', amount + 'px'); |
||
| 2827 | }; |
||
| 2828 | var setPercentageWidth = function (cell, amount) { |
||
| 2829 | set$1(cell, 'width', amount + '%'); |
||
| 2830 | }; |
||
| 2831 | var setHeight = function (cell, amount) { |
||
| 2832 | set$1(cell, 'height', amount + 'px'); |
||
| 2833 | }; |
||
| 2834 | var getHeightValue = function (cell) { |
||
| 679 | daniel-mar | 2835 | return getRuntime(cell) + 'px'; |
| 597 | daniel-mar | 2836 | }; |
| 2837 | var convert = function (cell, number, getter, setter) { |
||
| 2838 | var newSize = table(cell).map(function (table) { |
||
| 2839 | var total = getter(table); |
||
| 2840 | return Math.floor(number / 100 * total); |
||
| 2841 | }).getOr(number); |
||
| 2842 | setter(cell, newSize); |
||
| 2843 | return newSize; |
||
| 2844 | }; |
||
| 2845 | var normalizePixelSize = function (value, cell, getter, setter) { |
||
| 679 | daniel-mar | 2846 | var number = parseFloat(value); |
| 597 | daniel-mar | 2847 | return endsWith(value, '%') && name(cell) !== 'table' ? convert(cell, number, getter, setter) : number; |
| 2848 | }; |
||
| 2849 | var getTotalHeight = function (cell) { |
||
| 2850 | var value = getHeightValue(cell); |
||
| 2851 | if (!value) { |
||
| 637 | daniel-mar | 2852 | return get$7(cell); |
| 597 | daniel-mar | 2853 | } |
| 637 | daniel-mar | 2854 | return normalizePixelSize(value, cell, get$7, setHeight); |
| 597 | daniel-mar | 2855 | }; |
| 637 | daniel-mar | 2856 | var get$6 = function (cell, type, f) { |
| 597 | daniel-mar | 2857 | var v = f(cell); |
| 2858 | var span = getSpan(cell, type); |
||
| 2859 | return v / span; |
||
| 2860 | }; |
||
| 679 | daniel-mar | 2861 | var getRaw$1 = function (element, prop) { |
| 2862 | return getRaw$2(element, prop).orThunk(function () { |
||
| 2863 | return getOpt(element, prop).map(function (val) { |
||
| 2864 | return val + 'px'; |
||
| 2865 | }); |
||
| 597 | daniel-mar | 2866 | }); |
| 2867 | }; |
||
| 679 | daniel-mar | 2868 | var getRawWidth$1 = function (element) { |
| 2869 | return getRaw$1(element, 'width'); |
||
| 597 | daniel-mar | 2870 | }; |
| 679 | daniel-mar | 2871 | var getRawHeight = function (element) { |
| 2872 | return getRaw$1(element, 'height'); |
||
| 597 | daniel-mar | 2873 | }; |
| 679 | daniel-mar | 2874 | var getPercentageWidth = function (cell) { |
| 2875 | return getPercentSize(cell, get$8, getInner); |
||
| 597 | daniel-mar | 2876 | }; |
| 679 | daniel-mar | 2877 | var getPixelWidth$1 = function (cell) { |
| 2878 | return isCol$2(cell) ? get$8(cell) : getRuntime$1(cell); |
||
| 597 | daniel-mar | 2879 | }; |
| 637 | daniel-mar | 2880 | var getHeight = function (cell) { |
| 2881 | return get$6(cell, 'rowspan', getTotalHeight); |
||
| 597 | daniel-mar | 2882 | }; |
| 2883 | var getGenericWidth = function (cell) { |
||
| 637 | daniel-mar | 2884 | var width = getRawWidth$1(cell); |
| 597 | daniel-mar | 2885 | return width.bind(function (w) { |
| 2886 | return parse(w, [ |
||
| 2887 | 'fixed', |
||
| 2888 | 'relative', |
||
| 2889 | 'empty' |
||
| 2890 | ]); |
||
| 2891 | }); |
||
| 2892 | }; |
||
| 2893 | var setGenericWidth = function (cell, amount, unit) { |
||
| 2894 | set$1(cell, 'width', amount + unit); |
||
| 2895 | }; |
||
| 2896 | var getPixelTableWidth = function (table) { |
||
| 637 | daniel-mar | 2897 | return get$8(table) + 'px'; |
| 597 | daniel-mar | 2898 | }; |
| 679 | daniel-mar | 2899 | var getPercentTableWidth = function (table) { |
| 2900 | return getPercentSize(table, get$8, getInner) + '%'; |
||
| 597 | daniel-mar | 2901 | }; |
| 637 | daniel-mar | 2902 | var isPercentSizing$1 = function (table) { |
| 2903 | return getRawWidth$1(table).exists(function (size) { |
||
| 597 | daniel-mar | 2904 | return rPercentageBasedSizeRegex.test(size); |
| 2905 | }); |
||
| 2906 | }; |
||
| 637 | daniel-mar | 2907 | var isPixelSizing$1 = function (table) { |
| 2908 | return getRawWidth$1(table).exists(function (size) { |
||
| 597 | daniel-mar | 2909 | return rPixelBasedSizeRegex.test(size); |
| 2910 | }); |
||
| 2911 | }; |
||
| 637 | daniel-mar | 2912 | var isNoneSizing$1 = function (table) { |
| 2913 | return getRawWidth$1(table).isNone(); |
||
| 597 | daniel-mar | 2914 | }; |
| 2915 | var percentageBasedSizeRegex = constant(rPercentageBasedSizeRegex); |
||
| 2916 | |||
| 637 | daniel-mar | 2917 | var isCol$1 = isTag('col'); |
| 679 | daniel-mar | 2918 | var getRawW = function (cell) { |
| 2919 | return getRawWidth$1(cell).getOrThunk(function () { |
||
| 2920 | return getPixelWidth$1(cell) + 'px'; |
||
| 597 | daniel-mar | 2921 | }); |
| 2922 | }; |
||
| 2923 | var getRawH = function (cell) { |
||
| 679 | daniel-mar | 2924 | return getRawHeight(cell).getOrThunk(function () { |
| 2925 | return getHeight(cell) + 'px'; |
||
| 2926 | }); |
||
| 597 | daniel-mar | 2927 | }; |
| 2928 | var justCols = function (warehouse) { |
||
| 637 | daniel-mar | 2929 | return map$1(Warehouse.justColumns(warehouse), function (column) { |
| 597 | daniel-mar | 2930 | return Optional.from(column.element); |
| 2931 | }); |
||
| 2932 | }; |
||
| 2933 | var isValidColumn = function (cell) { |
||
| 679 | daniel-mar | 2934 | var browser = detect$3().browser; |
| 2935 | var supportsColWidths = browser.isChrome() || browser.isFirefox(); |
||
| 2936 | return isCol$1(cell) ? supportsColWidths : true; |
||
| 597 | daniel-mar | 2937 | }; |
| 2938 | var getDimension = function (cellOpt, index, backups, filter, getter, fallback) { |
||
| 2939 | return cellOpt.filter(filter).fold(function () { |
||
| 2940 | return fallback(deduce(backups, index)); |
||
| 2941 | }, function (cell) { |
||
| 2942 | return getter(cell); |
||
| 2943 | }); |
||
| 2944 | }; |
||
| 679 | daniel-mar | 2945 | var getWidthFrom = function (warehouse, table, getWidth, fallback) { |
| 2946 | var columnCells = columns(warehouse); |
||
| 637 | daniel-mar | 2947 | var columns$1 = Warehouse.hasColumns(warehouse) ? justCols(warehouse) : columnCells; |
| 2948 | var backups = [Optional.some(width.edge(table))].concat(map$1(width.positions(columnCells, table), function (pos) { |
||
| 597 | daniel-mar | 2949 | return pos.map(function (p) { |
| 2950 | return p.x; |
||
| 2951 | }); |
||
| 2952 | })); |
||
| 2953 | var colFilter = not(hasColspan); |
||
| 637 | daniel-mar | 2954 | return map$1(columns$1, function (cellOption, c) { |
| 597 | daniel-mar | 2955 | return getDimension(cellOption, c, backups, colFilter, function (column) { |
| 2956 | if (isValidColumn(column)) { |
||
| 679 | daniel-mar | 2957 | return getWidth(column); |
| 597 | daniel-mar | 2958 | } else { |
| 2959 | var cell = bindFrom(columnCells[c], identity); |
||
| 2960 | return getDimension(cell, c, backups, colFilter, function (cell) { |
||
| 637 | daniel-mar | 2961 | return fallback(Optional.some(get$8(cell))); |
| 597 | daniel-mar | 2962 | }, fallback); |
| 2963 | } |
||
| 2964 | }, fallback); |
||
| 2965 | }); |
||
| 2966 | }; |
||
| 2967 | var getDeduced = function (deduced) { |
||
| 2968 | return deduced.map(function (d) { |
||
| 2969 | return d + 'px'; |
||
| 2970 | }).getOr(''); |
||
| 2971 | }; |
||
| 679 | daniel-mar | 2972 | var getRawWidths = function (warehouse, table) { |
| 2973 | return getWidthFrom(warehouse, table, getRawW, getDeduced); |
||
| 597 | daniel-mar | 2974 | }; |
| 2975 | var getPercentageWidths = function (warehouse, table, tableSize) { |
||
| 2976 | return getWidthFrom(warehouse, table, getPercentageWidth, function (deduced) { |
||
| 2977 | return deduced.fold(function () { |
||
| 2978 | return tableSize.minCellWidth(); |
||
| 2979 | }, function (cellWidth) { |
||
| 2980 | return cellWidth / tableSize.pixelWidth() * 100; |
||
| 2981 | }); |
||
| 679 | daniel-mar | 2982 | }); |
| 597 | daniel-mar | 2983 | }; |
| 2984 | var getPixelWidths = function (warehouse, table, tableSize) { |
||
| 637 | daniel-mar | 2985 | return getWidthFrom(warehouse, table, getPixelWidth$1, function (deduced) { |
| 597 | daniel-mar | 2986 | return deduced.getOrThunk(tableSize.minCellWidth); |
| 679 | daniel-mar | 2987 | }); |
| 597 | daniel-mar | 2988 | }; |
| 2989 | var getHeightFrom = function (warehouse, table, direction, getHeight, fallback) { |
||
| 637 | daniel-mar | 2990 | var rows$1 = rows(warehouse); |
| 2991 | var backups = [Optional.some(direction.edge(table))].concat(map$1(direction.positions(rows$1, table), function (pos) { |
||
| 597 | daniel-mar | 2992 | return pos.map(function (p) { |
| 2993 | return p.y; |
||
| 2994 | }); |
||
| 2995 | })); |
||
| 637 | daniel-mar | 2996 | return map$1(rows$1, function (cellOption, c) { |
| 597 | daniel-mar | 2997 | return getDimension(cellOption, c, backups, not(hasRowspan), getHeight, fallback); |
| 2998 | }); |
||
| 2999 | }; |
||
| 3000 | var getPixelHeights = function (warehouse, table, direction) { |
||
| 637 | daniel-mar | 3001 | return getHeightFrom(warehouse, table, direction, getHeight, function (deduced) { |
| 597 | daniel-mar | 3002 | return deduced.getOrThunk(minHeight); |
| 3003 | }); |
||
| 3004 | }; |
||
| 3005 | var getRawHeights = function (warehouse, table, direction) { |
||
| 3006 | return getHeightFrom(warehouse, table, direction, getRawH, getDeduced); |
||
| 3007 | }; |
||
| 3008 | |||
| 679 | daniel-mar | 3009 | var widthLookup = function (table, getter) { |
| 3010 | return function () { |
||
| 3011 | if (inBody(table)) { |
||
| 3012 | return getter(table); |
||
| 3013 | } else { |
||
| 3014 | return parseFloat(getRaw$2(table, 'width').getOr('0')); |
||
| 3015 | } |
||
| 597 | daniel-mar | 3016 | }; |
| 3017 | }; |
||
| 3018 | var noneSize = function (table) { |
||
| 679 | daniel-mar | 3019 | var getWidth = widthLookup(table, get$8); |
| 597 | daniel-mar | 3020 | var zero = constant(0); |
| 3021 | var getWidths = function (warehouse, tableSize) { |
||
| 3022 | return getPixelWidths(warehouse, table, tableSize); |
||
| 3023 | }; |
||
| 3024 | return { |
||
| 3025 | width: getWidth, |
||
| 3026 | pixelWidth: getWidth, |
||
| 3027 | getWidths: getWidths, |
||
| 3028 | getCellDelta: zero, |
||
| 3029 | singleColumnWidth: constant([0]), |
||
| 3030 | minCellWidth: zero, |
||
| 3031 | setElementWidth: noop, |
||
| 3032 | adjustTableWidth: noop, |
||
| 3033 | isRelative: true, |
||
| 3034 | label: 'none' |
||
| 3035 | }; |
||
| 3036 | }; |
||
| 679 | daniel-mar | 3037 | var percentageSize = function (table) { |
| 3038 | var getFloatWidth = widthLookup(table, function (elem) { |
||
| 3039 | return parseFloat(getPercentTableWidth(elem)); |
||
| 3040 | }); |
||
| 3041 | var getWidth = widthLookup(table, get$8); |
||
| 597 | daniel-mar | 3042 | var getCellDelta = function (delta) { |
| 679 | daniel-mar | 3043 | return delta / getWidth() * 100; |
| 597 | daniel-mar | 3044 | }; |
| 3045 | var singleColumnWidth = function (w, _delta) { |
||
| 3046 | return [100 - w]; |
||
| 3047 | }; |
||
| 3048 | var minCellWidth = function () { |
||
| 679 | daniel-mar | 3049 | return minWidth() / getWidth() * 100; |
| 597 | daniel-mar | 3050 | }; |
| 3051 | var adjustTableWidth = function (delta) { |
||
| 679 | daniel-mar | 3052 | var currentWidth = getFloatWidth(); |
| 597 | daniel-mar | 3053 | var change = delta / 100 * currentWidth; |
| 3054 | var newWidth = currentWidth + change; |
||
| 3055 | setPercentageWidth(table, newWidth); |
||
| 3056 | }; |
||
| 3057 | var getWidths = function (warehouse, tableSize) { |
||
| 3058 | return getPercentageWidths(warehouse, table, tableSize); |
||
| 3059 | }; |
||
| 3060 | return { |
||
| 679 | daniel-mar | 3061 | width: getFloatWidth, |
| 3062 | pixelWidth: getWidth, |
||
| 597 | daniel-mar | 3063 | getWidths: getWidths, |
| 3064 | getCellDelta: getCellDelta, |
||
| 3065 | singleColumnWidth: singleColumnWidth, |
||
| 3066 | minCellWidth: minCellWidth, |
||
| 3067 | setElementWidth: setPercentageWidth, |
||
| 3068 | adjustTableWidth: adjustTableWidth, |
||
| 3069 | isRelative: true, |
||
| 3070 | label: 'percent' |
||
| 3071 | }; |
||
| 3072 | }; |
||
| 679 | daniel-mar | 3073 | var pixelSize = function (table) { |
| 3074 | var getWidth = widthLookup(table, get$8); |
||
| 597 | daniel-mar | 3075 | var getCellDelta = identity; |
| 3076 | var singleColumnWidth = function (w, delta) { |
||
| 3077 | var newNext = Math.max(minWidth(), w + delta); |
||
| 3078 | return [newNext - w]; |
||
| 3079 | }; |
||
| 3080 | var adjustTableWidth = function (delta) { |
||
| 3081 | var newWidth = getWidth() + delta; |
||
| 3082 | setPixelWidth(table, newWidth); |
||
| 3083 | }; |
||
| 3084 | var getWidths = function (warehouse, tableSize) { |
||
| 3085 | return getPixelWidths(warehouse, table, tableSize); |
||
| 3086 | }; |
||
| 3087 | return { |
||
| 3088 | width: getWidth, |
||
| 3089 | pixelWidth: getWidth, |
||
| 3090 | getWidths: getWidths, |
||
| 3091 | getCellDelta: getCellDelta, |
||
| 3092 | singleColumnWidth: singleColumnWidth, |
||
| 3093 | minCellWidth: minWidth, |
||
| 3094 | setElementWidth: setPixelWidth, |
||
| 3095 | adjustTableWidth: adjustTableWidth, |
||
| 3096 | isRelative: false, |
||
| 3097 | label: 'pixel' |
||
| 3098 | }; |
||
| 3099 | }; |
||
| 3100 | var chooseSize = function (element, width) { |
||
| 3101 | var percentMatch = percentageBasedSizeRegex().exec(width); |
||
| 3102 | if (percentMatch !== null) { |
||
| 679 | daniel-mar | 3103 | return percentageSize(element); |
| 3104 | } else { |
||
| 3105 | return pixelSize(element); |
||
| 597 | daniel-mar | 3106 | } |
| 3107 | }; |
||
| 3108 | var getTableSize = function (table) { |
||
| 637 | daniel-mar | 3109 | var width = getRawWidth$1(table); |
| 597 | daniel-mar | 3110 | return width.fold(function () { |
| 3111 | return noneSize(table); |
||
| 3112 | }, function (w) { |
||
| 3113 | return chooseSize(table, w); |
||
| 3114 | }); |
||
| 3115 | }; |
||
| 3116 | var TableSize = { |
||
| 3117 | getTableSize: getTableSize, |
||
| 3118 | pixelSize: pixelSize, |
||
| 3119 | percentageSize: percentageSize, |
||
| 3120 | noneSize: noneSize |
||
| 3121 | }; |
||
| 3122 | |||
| 3123 | var statsStruct = function (minRow, minCol, maxRow, maxCol, allCells, selectedCells) { |
||
| 3124 | return { |
||
| 3125 | minRow: minRow, |
||
| 3126 | minCol: minCol, |
||
| 3127 | maxRow: maxRow, |
||
| 3128 | maxCol: maxCol, |
||
| 3129 | allCells: allCells, |
||
| 3130 | selectedCells: selectedCells |
||
| 3131 | }; |
||
| 3132 | }; |
||
| 3133 | var findSelectedStats = function (house, isSelected) { |
||
| 3134 | var totalColumns = house.grid.columns; |
||
| 3135 | var totalRows = house.grid.rows; |
||
| 3136 | var minRow = totalRows; |
||
| 3137 | var minCol = totalColumns; |
||
| 3138 | var maxRow = 0; |
||
| 3139 | var maxCol = 0; |
||
| 3140 | var allCells = []; |
||
| 3141 | var selectedCells = []; |
||
| 3142 | each$1(house.access, function (detail) { |
||
| 3143 | allCells.push(detail); |
||
| 3144 | if (isSelected(detail)) { |
||
| 3145 | selectedCells.push(detail); |
||
| 3146 | var startRow = detail.row; |
||
| 3147 | var endRow = startRow + detail.rowspan - 1; |
||
| 3148 | var startCol = detail.column; |
||
| 3149 | var endCol = startCol + detail.colspan - 1; |
||
| 3150 | if (startRow < minRow) { |
||
| 3151 | minRow = startRow; |
||
| 3152 | } else if (endRow > maxRow) { |
||
| 3153 | maxRow = endRow; |
||
| 3154 | } |
||
| 3155 | if (startCol < minCol) { |
||
| 3156 | minCol = startCol; |
||
| 3157 | } else if (endCol > maxCol) { |
||
| 3158 | maxCol = endCol; |
||
| 3159 | } |
||
| 3160 | } |
||
| 3161 | }); |
||
| 3162 | return statsStruct(minRow, minCol, maxRow, maxCol, allCells, selectedCells); |
||
| 3163 | }; |
||
| 3164 | var makeCell = function (list, seenSelected, rowIndex) { |
||
| 3165 | var row = list[rowIndex].element; |
||
| 3166 | var td = SugarElement.fromTag('td'); |
||
| 637 | daniel-mar | 3167 | append$1(td, SugarElement.fromTag('br')); |
| 3168 | var f = seenSelected ? append$1 : prepend; |
||
| 597 | daniel-mar | 3169 | f(row, td); |
| 3170 | }; |
||
| 3171 | var fillInGaps = function (list, house, stats, isSelected) { |
||
| 3172 | var totalColumns = house.grid.columns; |
||
| 3173 | var totalRows = house.grid.rows; |
||
| 3174 | for (var i = 0; i < totalRows; i++) { |
||
| 3175 | var seenSelected = false; |
||
| 3176 | for (var j = 0; j < totalColumns; j++) { |
||
| 3177 | if (!(i < stats.minRow || i > stats.maxRow || j < stats.minCol || j > stats.maxCol)) { |
||
| 3178 | var needCell = Warehouse.getAt(house, i, j).filter(isSelected).isNone(); |
||
| 3179 | if (needCell) { |
||
| 3180 | makeCell(list, seenSelected, i); |
||
| 3181 | } else { |
||
| 3182 | seenSelected = true; |
||
| 3183 | } |
||
| 3184 | } |
||
| 3185 | } |
||
| 3186 | } |
||
| 3187 | }; |
||
| 3188 | var clean = function (replica, stats, house, widthDelta) { |
||
| 3189 | each$1(house.columns, function (col) { |
||
| 3190 | if (col.column < stats.minCol || col.column > stats.maxCol) { |
||
| 637 | daniel-mar | 3191 | remove$5(col.element); |
| 597 | daniel-mar | 3192 | } |
| 3193 | }); |
||
| 637 | daniel-mar | 3194 | var emptyRows = filter$2(firstLayer(replica, 'tr'), function (row) { |
| 597 | daniel-mar | 3195 | return row.dom.childElementCount === 0; |
| 3196 | }); |
||
| 637 | daniel-mar | 3197 | each$2(emptyRows, remove$5); |
| 597 | daniel-mar | 3198 | if (stats.minCol === stats.maxCol || stats.minRow === stats.maxRow) { |
| 637 | daniel-mar | 3199 | each$2(firstLayer(replica, 'th,td'), function (cell) { |
| 3200 | remove$7(cell, 'rowspan'); |
||
| 3201 | remove$7(cell, 'colspan'); |
||
| 597 | daniel-mar | 3202 | }); |
| 3203 | } |
||
| 637 | daniel-mar | 3204 | remove$7(replica, LOCKED_COL_ATTR); |
| 3205 | remove$7(replica, 'data-snooker-col-series'); |
||
| 597 | daniel-mar | 3206 | var tableSize = TableSize.getTableSize(replica); |
| 3207 | tableSize.adjustTableWidth(widthDelta); |
||
| 3208 | }; |
||
| 3209 | var getTableWidthDelta = function (table, warehouse, tableSize, stats) { |
||
| 3210 | if (stats.minCol === 0 && warehouse.grid.columns === stats.maxCol + 1) { |
||
| 3211 | return 0; |
||
| 3212 | } |
||
| 3213 | var colWidths = getPixelWidths(warehouse, table, tableSize); |
||
| 3214 | var allColsWidth = foldl(colWidths, function (acc, width) { |
||
| 3215 | return acc + width; |
||
| 3216 | }, 0); |
||
| 3217 | var selectedColsWidth = foldl(colWidths.slice(stats.minCol, stats.maxCol + 1), function (acc, width) { |
||
| 3218 | return acc + width; |
||
| 3219 | }, 0); |
||
| 3220 | var newWidth = selectedColsWidth / allColsWidth * tableSize.pixelWidth(); |
||
| 3221 | var delta = newWidth - tableSize.pixelWidth(); |
||
| 3222 | return tableSize.getCellDelta(delta); |
||
| 3223 | }; |
||
| 637 | daniel-mar | 3224 | var extract$1 = function (table, selectedSelector) { |
| 597 | daniel-mar | 3225 | var isSelected = function (detail) { |
| 637 | daniel-mar | 3226 | return is$2(detail.element, selectedSelector); |
| 597 | daniel-mar | 3227 | }; |
| 3228 | var replica = deep(table); |
||
| 637 | daniel-mar | 3229 | var list = fromTable$1(replica); |
| 597 | daniel-mar | 3230 | var tableSize = TableSize.getTableSize(table); |
| 3231 | var replicaHouse = Warehouse.generate(list); |
||
| 3232 | var replicaStats = findSelectedStats(replicaHouse, isSelected); |
||
| 3233 | var selector = 'th:not(' + selectedSelector + ')' + ',td:not(' + selectedSelector + ')'; |
||
| 3234 | var unselectedCells = filterFirstLayer(replica, 'th,td', function (cell) { |
||
| 637 | daniel-mar | 3235 | return is$2(cell, selector); |
| 597 | daniel-mar | 3236 | }); |
| 637 | daniel-mar | 3237 | each$2(unselectedCells, remove$5); |
| 597 | daniel-mar | 3238 | fillInGaps(list, replicaHouse, replicaStats, isSelected); |
| 3239 | var house = Warehouse.fromTable(table); |
||
| 3240 | var widthDelta = getTableWidthDelta(table, house, tableSize, replicaStats); |
||
| 3241 | clean(replica, replicaStats, replicaHouse, widthDelta); |
||
| 3242 | return replica; |
||
| 3243 | }; |
||
| 3244 | |||
| 3245 | var nbsp = '\xA0'; |
||
| 3246 | |||
| 3247 | var getEnd = function (element) { |
||
| 3248 | return name(element) === 'img' ? 1 : getOption(element).fold(function () { |
||
| 637 | daniel-mar | 3249 | return children$3(element).length; |
| 597 | daniel-mar | 3250 | }, function (v) { |
| 3251 | return v.length; |
||
| 3252 | }); |
||
| 3253 | }; |
||
| 3254 | var isTextNodeWithCursorPosition = function (el) { |
||
| 3255 | return getOption(el).filter(function (text) { |
||
| 3256 | return text.trim().length !== 0 || text.indexOf(nbsp) > -1; |
||
| 3257 | }).isSome(); |
||
| 3258 | }; |
||
| 3259 | var elementsWithCursorPosition = [ |
||
| 3260 | 'img', |
||
| 3261 | 'br' |
||
| 3262 | ]; |
||
| 3263 | var isCursorPosition = function (elem) { |
||
| 3264 | var hasCursorPosition = isTextNodeWithCursorPosition(elem); |
||
| 637 | daniel-mar | 3265 | return hasCursorPosition || contains$2(elementsWithCursorPosition, name(elem)); |
| 597 | daniel-mar | 3266 | }; |
| 3267 | |||
| 3268 | var first = function (element) { |
||
| 637 | daniel-mar | 3269 | return descendant$1(element, isCursorPosition); |
| 597 | daniel-mar | 3270 | }; |
| 3271 | var last$1 = function (element) { |
||
| 3272 | return descendantRtl(element, isCursorPosition); |
||
| 3273 | }; |
||
| 3274 | var descendantRtl = function (scope, predicate) { |
||
| 3275 | var descend = function (element) { |
||
| 637 | daniel-mar | 3276 | var children = children$3(element); |
| 3277 | for (var i = children.length - 1; i >= 0; i--) { |
||
| 3278 | var child = children[i]; |
||
| 597 | daniel-mar | 3279 | if (predicate(child)) { |
| 3280 | return Optional.some(child); |
||
| 3281 | } |
||
| 3282 | var res = descend(child); |
||
| 3283 | if (res.isSome()) { |
||
| 3284 | return res; |
||
| 3285 | } |
||
| 3286 | } |
||
| 3287 | return Optional.none(); |
||
| 3288 | }; |
||
| 3289 | return descend(scope); |
||
| 3290 | }; |
||
| 3291 | |||
| 3292 | var transferableAttributes = { |
||
| 3293 | scope: [ |
||
| 3294 | 'row', |
||
| 3295 | 'col' |
||
| 3296 | ] |
||
| 3297 | }; |
||
| 637 | daniel-mar | 3298 | var createCell = function (doc) { |
| 3299 | return function () { |
||
| 3300 | var td = SugarElement.fromTag('td', doc.dom); |
||
| 3301 | append$1(td, SugarElement.fromTag('br', doc.dom)); |
||
| 3302 | return td; |
||
| 3303 | }; |
||
| 597 | daniel-mar | 3304 | }; |
| 637 | daniel-mar | 3305 | var createCol = function (doc) { |
| 3306 | return function () { |
||
| 3307 | return SugarElement.fromTag('col', doc.dom); |
||
| 3308 | }; |
||
| 597 | daniel-mar | 3309 | }; |
| 637 | daniel-mar | 3310 | var createColgroup = function (doc) { |
| 3311 | return function () { |
||
| 3312 | return SugarElement.fromTag('colgroup', doc.dom); |
||
| 3313 | }; |
||
| 597 | daniel-mar | 3314 | }; |
| 637 | daniel-mar | 3315 | var createRow$1 = function (doc) { |
| 3316 | return function () { |
||
| 3317 | return SugarElement.fromTag('tr', doc.dom); |
||
| 3318 | }; |
||
| 3319 | }; |
||
| 3320 | var replace$1 = function (cell, tag, attrs) { |
||
| 597 | daniel-mar | 3321 | var replica = copy$1(cell, tag); |
| 3322 | each$1(attrs, function (v, k) { |
||
| 3323 | if (v === null) { |
||
| 637 | daniel-mar | 3324 | remove$7(replica, k); |
| 597 | daniel-mar | 3325 | } else { |
| 637 | daniel-mar | 3326 | set$2(replica, k, v); |
| 597 | daniel-mar | 3327 | } |
| 3328 | }); |
||
| 3329 | return replica; |
||
| 3330 | }; |
||
| 3331 | var pasteReplace = function (cell) { |
||
| 3332 | return cell; |
||
| 3333 | }; |
||
| 3334 | var cloneFormats = function (oldCell, newCell, formats) { |
||
| 3335 | var first$1 = first(oldCell); |
||
| 3336 | return first$1.map(function (firstText) { |
||
| 3337 | var formatSelector = formats.join(','); |
||
| 637 | daniel-mar | 3338 | var parents = ancestors$3(firstText, formatSelector, function (element) { |
| 597 | daniel-mar | 3339 | return eq$1(element, oldCell); |
| 3340 | }); |
||
| 3341 | return foldr(parents, function (last, parent) { |
||
| 3342 | var clonedFormat = shallow(parent); |
||
| 637 | daniel-mar | 3343 | remove$7(clonedFormat, 'contenteditable'); |
| 3344 | append$1(last, clonedFormat); |
||
| 597 | daniel-mar | 3345 | return clonedFormat; |
| 3346 | }, newCell); |
||
| 3347 | }).getOr(newCell); |
||
| 3348 | }; |
||
| 3349 | var cloneAppropriateAttributes = function (original, clone) { |
||
| 3350 | each$1(transferableAttributes, function (validAttributes, attributeName) { |
||
| 3351 | return getOpt(original, attributeName).filter(function (attribute) { |
||
| 637 | daniel-mar | 3352 | return contains$2(validAttributes, attribute); |
| 597 | daniel-mar | 3353 | }).each(function (attribute) { |
| 637 | daniel-mar | 3354 | return set$2(clone, attributeName, attribute); |
| 597 | daniel-mar | 3355 | }); |
| 3356 | }); |
||
| 3357 | }; |
||
| 3358 | var cellOperations = function (mutate, doc, formatsToClone) { |
||
| 3359 | var cloneCss = function (prev, clone) { |
||
| 637 | daniel-mar | 3360 | copy$2(prev.element, clone); |
| 3361 | remove$6(clone, 'height'); |
||
| 597 | daniel-mar | 3362 | if (prev.colspan !== 1) { |
| 637 | daniel-mar | 3363 | remove$6(clone, 'width'); |
| 597 | daniel-mar | 3364 | } |
| 3365 | }; |
||
| 3366 | var newCell = function (prev) { |
||
| 637 | daniel-mar | 3367 | var td = SugarElement.fromTag(name(prev.element), doc.dom); |
| 597 | daniel-mar | 3368 | var formats = formatsToClone.getOr([ |
| 3369 | 'strong', |
||
| 3370 | 'em', |
||
| 3371 | 'b', |
||
| 3372 | 'i', |
||
| 3373 | 'span', |
||
| 3374 | 'font', |
||
| 3375 | 'h1', |
||
| 3376 | 'h2', |
||
| 3377 | 'h3', |
||
| 3378 | 'h4', |
||
| 3379 | 'h5', |
||
| 3380 | 'h6', |
||
| 3381 | 'p', |
||
| 3382 | 'div' |
||
| 3383 | ]); |
||
| 3384 | var lastNode = formats.length > 0 ? cloneFormats(prev.element, td, formats) : td; |
||
| 637 | daniel-mar | 3385 | append$1(lastNode, SugarElement.fromTag('br')); |
| 597 | daniel-mar | 3386 | cloneCss(prev, td); |
| 3387 | cloneAppropriateAttributes(prev.element, td); |
||
| 3388 | mutate(prev.element, td); |
||
| 3389 | return td; |
||
| 3390 | }; |
||
| 3391 | var newCol = function (prev) { |
||
| 3392 | var col = SugarElement.fromTag(name(prev.element), doc.dom); |
||
| 3393 | cloneCss(prev, col); |
||
| 3394 | mutate(prev.element, col); |
||
| 3395 | return col; |
||
| 3396 | }; |
||
| 3397 | return { |
||
| 3398 | col: newCol, |
||
| 637 | daniel-mar | 3399 | colgroup: createColgroup(doc), |
| 3400 | row: createRow$1(doc), |
||
| 597 | daniel-mar | 3401 | cell: newCell, |
| 637 | daniel-mar | 3402 | replace: replace$1, |
| 679 | daniel-mar | 3403 | colGap: createCol(doc), |
| 637 | daniel-mar | 3404 | gap: createCell(doc) |
| 597 | daniel-mar | 3405 | }; |
| 3406 | }; |
||
| 637 | daniel-mar | 3407 | var paste$1 = function (doc) { |
| 597 | daniel-mar | 3408 | return { |
| 637 | daniel-mar | 3409 | col: createCol(doc), |
| 3410 | colgroup: createColgroup(doc), |
||
| 3411 | row: createRow$1(doc), |
||
| 3412 | cell: createCell(doc), |
||
| 597 | daniel-mar | 3413 | replace: pasteReplace, |
| 679 | daniel-mar | 3414 | colGap: createCol(doc), |
| 637 | daniel-mar | 3415 | gap: createCell(doc) |
| 597 | daniel-mar | 3416 | }; |
| 3417 | }; |
||
| 3418 | |||
| 637 | daniel-mar | 3419 | var fromHtml = function (html, scope) { |
| 597 | daniel-mar | 3420 | var doc = scope || document; |
| 3421 | var div = doc.createElement('div'); |
||
| 3422 | div.innerHTML = html; |
||
| 637 | daniel-mar | 3423 | return children$3(SugarElement.fromDom(div)); |
| 597 | daniel-mar | 3424 | }; |
| 637 | daniel-mar | 3425 | var fromDom = function (nodes) { |
| 3426 | return map$1(nodes, SugarElement.fromDom); |
||
| 597 | daniel-mar | 3427 | }; |
| 3428 | |||
| 3429 | var getNodeName = function (elm) { |
||
| 3430 | return elm.nodeName.toLowerCase(); |
||
| 3431 | }; |
||
| 637 | daniel-mar | 3432 | var getBody = function (editor) { |
| 597 | daniel-mar | 3433 | return SugarElement.fromDom(editor.getBody()); |
| 3434 | }; |
||
| 637 | daniel-mar | 3435 | var getPixelWidth = function (elm) { |
| 597 | daniel-mar | 3436 | return elm.getBoundingClientRect().width; |
| 3437 | }; |
||
| 3438 | var getPixelHeight = function (elm) { |
||
| 3439 | return elm.getBoundingClientRect().height; |
||
| 3440 | }; |
||
| 3441 | var getIsRoot = function (editor) { |
||
| 3442 | return function (element) { |
||
| 637 | daniel-mar | 3443 | return eq$1(element, getBody(editor)); |
| 597 | daniel-mar | 3444 | }; |
| 3445 | }; |
||
| 3446 | var removePxSuffix = function (size) { |
||
| 3447 | return size ? size.replace(/px$/, '') : ''; |
||
| 3448 | }; |
||
| 3449 | var addPxSuffix = function (size) { |
||
| 3450 | return /^\d+(\.\d+)?$/.test(size) ? size + 'px' : size; |
||
| 3451 | }; |
||
| 3452 | var removeDataStyle = function (table) { |
||
| 637 | daniel-mar | 3453 | remove$7(table, 'data-mce-style'); |
| 597 | daniel-mar | 3454 | var removeStyleAttribute = function (element) { |
| 637 | daniel-mar | 3455 | return remove$7(element, 'data-mce-style'); |
| 597 | daniel-mar | 3456 | }; |
| 637 | daniel-mar | 3457 | each$2(cells$1(table), removeStyleAttribute); |
| 3458 | each$2(columns$1(table), removeStyleAttribute); |
||
| 679 | daniel-mar | 3459 | each$2(rows$1(table), removeStyleAttribute); |
| 597 | daniel-mar | 3460 | }; |
| 637 | daniel-mar | 3461 | var getRawWidth = function (editor, elm) { |
| 597 | daniel-mar | 3462 | var raw = editor.dom.getStyle(elm, 'width') || editor.dom.getAttrib(elm, 'width'); |
| 3463 | return Optional.from(raw).filter(isNotEmpty); |
||
| 3464 | }; |
||
| 637 | daniel-mar | 3465 | var isPercentage$1 = function (value) { |
| 597 | daniel-mar | 3466 | return /^(\d+(\.\d+)?)%$/.test(value); |
| 3467 | }; |
||
| 3468 | var isPixel = function (value) { |
||
| 3469 | return /^(\d+(\.\d+)?)px$/.test(value); |
||
| 3470 | }; |
||
| 3471 | var getSelectionStart = function (editor) { |
||
| 3472 | return SugarElement.fromDom(editor.selection.getStart()); |
||
| 3473 | }; |
||
| 637 | daniel-mar | 3474 | var getSelectionEnd = function (editor) { |
| 3475 | return SugarElement.fromDom(editor.selection.getEnd()); |
||
| 3476 | }; |
||
| 597 | daniel-mar | 3477 | |
| 3478 | var selection = function (selections) { |
||
| 637 | daniel-mar | 3479 | return cata$2(selections.get(), constant([]), identity, pure); |
| 597 | daniel-mar | 3480 | }; |
| 3481 | var unmergable = function (selections) { |
||
| 3482 | var hasSpan = function (elem, type) { |
||
| 3483 | return getOpt(elem, type).exists(function (span) { |
||
| 3484 | return parseInt(span, 10) > 1; |
||
| 3485 | }); |
||
| 3486 | }; |
||
| 3487 | var hasRowOrColSpan = function (elem) { |
||
| 3488 | return hasSpan(elem, 'rowspan') || hasSpan(elem, 'colspan'); |
||
| 3489 | }; |
||
| 3490 | var candidates = selection(selections); |
||
| 3491 | return candidates.length > 0 && forall(candidates, hasRowOrColSpan) ? Optional.some(candidates) : Optional.none(); |
||
| 3492 | }; |
||
| 3493 | var mergable = function (table, selections, ephemera) { |
||
| 637 | daniel-mar | 3494 | return cata$2(selections.get(), Optional.none, function (cells) { |
| 597 | daniel-mar | 3495 | if (cells.length <= 1) { |
| 3496 | return Optional.none(); |
||
| 3497 | } else { |
||
| 3498 | return retrieveBox(table, ephemera.firstSelectedSelector, ephemera.lastSelectedSelector).map(function (bounds) { |
||
| 3499 | return { |
||
| 3500 | bounds: bounds, |
||
| 3501 | cells: cells |
||
| 3502 | }; |
||
| 3503 | }); |
||
| 3504 | } |
||
| 3505 | }, Optional.none); |
||
| 3506 | }; |
||
| 3507 | |||
| 3508 | var strSelected = 'data-mce-selected'; |
||
| 3509 | var strSelectedSelector = 'td[' + strSelected + '],th[' + strSelected + ']'; |
||
| 3510 | var strAttributeSelector = '[' + strSelected + ']'; |
||
| 3511 | var strFirstSelected = 'data-mce-first-selected'; |
||
| 3512 | var strFirstSelectedSelector = 'td[' + strFirstSelected + '],th[' + strFirstSelected + ']'; |
||
| 3513 | var strLastSelected = 'data-mce-last-selected'; |
||
| 3514 | var strLastSelectedSelector = 'td[' + strLastSelected + '],th[' + strLastSelected + ']'; |
||
| 3515 | var attributeSelector = strAttributeSelector; |
||
| 3516 | var ephemera = { |
||
| 3517 | selected: strSelected, |
||
| 3518 | selectedSelector: strSelectedSelector, |
||
| 3519 | firstSelected: strFirstSelected, |
||
| 3520 | firstSelectedSelector: strFirstSelectedSelector, |
||
| 3521 | lastSelected: strLastSelected, |
||
| 3522 | lastSelectedSelector: strLastSelectedSelector |
||
| 3523 | }; |
||
| 3524 | |||
| 3525 | var noMenu = function (cell) { |
||
| 3526 | return { |
||
| 3527 | element: cell, |
||
| 3528 | mergable: Optional.none(), |
||
| 3529 | unmergable: Optional.none(), |
||
| 3530 | selection: [cell] |
||
| 3531 | }; |
||
| 3532 | }; |
||
| 3533 | var forMenu = function (selections, table, cell) { |
||
| 3534 | return { |
||
| 3535 | element: cell, |
||
| 3536 | mergable: mergable(table, selections, ephemera), |
||
| 3537 | unmergable: unmergable(selections), |
||
| 3538 | selection: selection(selections) |
||
| 3539 | }; |
||
| 3540 | }; |
||
| 637 | daniel-mar | 3541 | var paste = function (element, clipboard, generators) { |
| 597 | daniel-mar | 3542 | return { |
| 3543 | element: element, |
||
| 3544 | clipboard: clipboard, |
||
| 3545 | generators: generators |
||
| 3546 | }; |
||
| 3547 | }; |
||
| 3548 | var pasteRows = function (selections, cell, clipboard, generators) { |
||
| 3549 | return { |
||
| 3550 | selection: selection(selections), |
||
| 3551 | clipboard: clipboard, |
||
| 3552 | generators: generators |
||
| 3553 | }; |
||
| 3554 | }; |
||
| 3555 | |||
| 637 | daniel-mar | 3556 | var getSelectionCellFallback = function (element) { |
| 3557 | return table(element).bind(function (table) { |
||
| 3558 | return retrieve(table, ephemera.firstSelectedSelector); |
||
| 3559 | }).fold(constant(element), function (cells) { |
||
| 3560 | return cells[0]; |
||
| 3561 | }); |
||
| 3562 | }; |
||
| 3563 | var getSelectionFromSelector = function (selector) { |
||
| 3564 | return function (initCell, isRoot) { |
||
| 3565 | var cellName = name(initCell); |
||
| 3566 | var cell = cellName === 'col' || cellName === 'colgroup' ? getSelectionCellFallback(initCell) : initCell; |
||
| 3567 | return closest$1(cell, selector, isRoot); |
||
| 3568 | }; |
||
| 3569 | }; |
||
| 3570 | var getSelectionCellOrCaption = getSelectionFromSelector('th,td,caption'); |
||
| 3571 | var getSelectionCell = getSelectionFromSelector('th,td'); |
||
| 3572 | var getCellsFromSelection = function (selections) { |
||
| 3573 | return selection(selections); |
||
| 3574 | }; |
||
| 3575 | var getRowsFromSelection = function (selected, selector) { |
||
| 3576 | var cellOpt = getSelectionCell(selected); |
||
| 3577 | var rowsOpt = cellOpt.bind(function (cell) { |
||
| 3578 | return table(cell); |
||
| 3579 | }).map(function (table) { |
||
| 3580 | return rows$1(table); |
||
| 3581 | }); |
||
| 3582 | return lift2(cellOpt, rowsOpt, function (cell, rows) { |
||
| 3583 | return filter$2(rows, function (row) { |
||
| 3584 | return exists(fromDom(row.dom.cells), function (rowCell) { |
||
| 3585 | return get$b(rowCell, selector) === '1' || eq$1(rowCell, cell); |
||
| 3586 | }); |
||
| 3587 | }); |
||
| 3588 | }).getOr([]); |
||
| 3589 | }; |
||
| 3590 | |||
| 597 | daniel-mar | 3591 | var extractSelected = function (cells) { |
| 3592 | return table(cells[0]).map(function (table) { |
||
| 637 | daniel-mar | 3593 | var replica = extract$1(table, attributeSelector); |
| 597 | daniel-mar | 3594 | removeDataStyle(replica); |
| 3595 | return [replica]; |
||
| 3596 | }); |
||
| 3597 | }; |
||
| 3598 | var serializeElements = function (editor, elements) { |
||
| 637 | daniel-mar | 3599 | return map$1(elements, function (elm) { |
| 597 | daniel-mar | 3600 | return editor.selection.serializer.serialize(elm.dom, {}); |
| 3601 | }).join(''); |
||
| 3602 | }; |
||
| 3603 | var getTextContent = function (elements) { |
||
| 637 | daniel-mar | 3604 | return map$1(elements, function (element) { |
| 597 | daniel-mar | 3605 | return element.dom.innerText; |
| 3606 | }).join(''); |
||
| 3607 | }; |
||
| 637 | daniel-mar | 3608 | var registerEvents = function (editor, selections, actions) { |
| 597 | daniel-mar | 3609 | editor.on('BeforeGetContent', function (e) { |
| 3610 | var multiCellContext = function (cells) { |
||
| 3611 | e.preventDefault(); |
||
| 3612 | extractSelected(cells).each(function (elements) { |
||
| 3613 | e.content = e.format === 'text' ? getTextContent(elements) : serializeElements(editor, elements); |
||
| 3614 | }); |
||
| 3615 | }; |
||
| 3616 | if (e.selection === true) { |
||
| 637 | daniel-mar | 3617 | cata$2(selections.get(), noop, multiCellContext, noop); |
| 597 | daniel-mar | 3618 | } |
| 3619 | }); |
||
| 3620 | editor.on('BeforeSetContent', function (e) { |
||
| 3621 | if (e.selection === true && e.paste === true) { |
||
| 637 | daniel-mar | 3622 | var selectedCells = getCellsFromSelection(selections); |
| 3623 | head(selectedCells).each(function (cell) { |
||
| 597 | daniel-mar | 3624 | table(cell).each(function (table) { |
| 637 | daniel-mar | 3625 | var elements = filter$2(fromHtml(e.content), function (content) { |
| 597 | daniel-mar | 3626 | return name(content) !== 'meta'; |
| 3627 | }); |
||
| 637 | daniel-mar | 3628 | var isTable = isTag('table'); |
| 597 | daniel-mar | 3629 | if (elements.length === 1 && isTable(elements[0])) { |
| 3630 | e.preventDefault(); |
||
| 3631 | var doc = SugarElement.fromDom(editor.getDoc()); |
||
| 637 | daniel-mar | 3632 | var generators = paste$1(doc); |
| 3633 | var targets = paste(cell, elements[0], generators); |
||
| 3634 | actions.pasteCells(table, targets).each(function () { |
||
| 597 | daniel-mar | 3635 | editor.focus(); |
| 3636 | }); |
||
| 3637 | } |
||
| 3638 | }); |
||
| 3639 | }); |
||
| 3640 | } |
||
| 3641 | }); |
||
| 3642 | }; |
||
| 3643 | |||
| 637 | daniel-mar | 3644 | var adt$7 = Adt.generate([ |
| 597 | daniel-mar | 3645 | { none: [] }, |
| 3646 | { only: ['index'] }, |
||
| 3647 | { |
||
| 3648 | left: [ |
||
| 3649 | 'index', |
||
| 3650 | 'next' |
||
| 3651 | ] |
||
| 3652 | }, |
||
| 3653 | { |
||
| 3654 | middle: [ |
||
| 3655 | 'prev', |
||
| 3656 | 'index', |
||
| 3657 | 'next' |
||
| 3658 | ] |
||
| 3659 | }, |
||
| 3660 | { |
||
| 3661 | right: [ |
||
| 3662 | 'prev', |
||
| 3663 | 'index' |
||
| 3664 | ] |
||
| 3665 | } |
||
| 3666 | ]); |
||
| 637 | daniel-mar | 3667 | var ColumnContext = __assign({}, adt$7); |
| 597 | daniel-mar | 3668 | |
| 3669 | var neighbours = function (input, index) { |
||
| 3670 | if (input.length === 0) { |
||
| 3671 | return ColumnContext.none(); |
||
| 3672 | } |
||
| 3673 | if (input.length === 1) { |
||
| 3674 | return ColumnContext.only(0); |
||
| 3675 | } |
||
| 3676 | if (index === 0) { |
||
| 3677 | return ColumnContext.left(0, 1); |
||
| 3678 | } |
||
| 3679 | if (index === input.length - 1) { |
||
| 3680 | return ColumnContext.right(index - 1, index); |
||
| 3681 | } |
||
| 3682 | if (index > 0 && index < input.length - 1) { |
||
| 3683 | return ColumnContext.middle(index - 1, index, index + 1); |
||
| 3684 | } |
||
| 3685 | return ColumnContext.none(); |
||
| 3686 | }; |
||
| 3687 | var determine = function (input, column, step, tableSize, resize) { |
||
| 3688 | var result = input.slice(0); |
||
| 3689 | var context = neighbours(input, column); |
||
| 637 | daniel-mar | 3690 | var onNone = constant(map$1(result, constant(0))); |
| 597 | daniel-mar | 3691 | var onOnly = function (index) { |
| 3692 | return tableSize.singleColumnWidth(result[index], step); |
||
| 3693 | }; |
||
| 3694 | var onLeft = function (index, next) { |
||
| 3695 | return resize.calcLeftEdgeDeltas(result, index, next, step, tableSize.minCellWidth(), tableSize.isRelative); |
||
| 3696 | }; |
||
| 3697 | var onMiddle = function (prev, index, next) { |
||
| 3698 | return resize.calcMiddleDeltas(result, prev, index, next, step, tableSize.minCellWidth(), tableSize.isRelative); |
||
| 3699 | }; |
||
| 3700 | var onRight = function (prev, index) { |
||
| 3701 | return resize.calcRightEdgeDeltas(result, prev, index, step, tableSize.minCellWidth(), tableSize.isRelative); |
||
| 3702 | }; |
||
| 3703 | return context.fold(onNone, onOnly, onLeft, onMiddle, onRight); |
||
| 3704 | }; |
||
| 3705 | |||
| 3706 | var total = function (start, end, measures) { |
||
| 3707 | var r = 0; |
||
| 3708 | for (var i = start; i < end; i++) { |
||
| 3709 | r += measures[i] !== undefined ? measures[i] : 0; |
||
| 3710 | } |
||
| 3711 | return r; |
||
| 3712 | }; |
||
| 3713 | var recalculateWidthForCells = function (warehouse, widths) { |
||
| 3714 | var all = Warehouse.justCells(warehouse); |
||
| 637 | daniel-mar | 3715 | return map$1(all, function (cell) { |
| 597 | daniel-mar | 3716 | var width = total(cell.column, cell.column + cell.colspan, widths); |
| 3717 | return { |
||
| 3718 | element: cell.element, |
||
| 3719 | width: width, |
||
| 3720 | colspan: cell.colspan |
||
| 3721 | }; |
||
| 3722 | }); |
||
| 3723 | }; |
||
| 3724 | var recalculateWidthForColumns = function (warehouse, widths) { |
||
| 3725 | var groups = Warehouse.justColumns(warehouse); |
||
| 637 | daniel-mar | 3726 | return map$1(groups, function (column, index) { |
| 597 | daniel-mar | 3727 | return { |
| 3728 | element: column.element, |
||
| 3729 | width: widths[index], |
||
| 3730 | colspan: column.colspan |
||
| 3731 | }; |
||
| 3732 | }); |
||
| 3733 | }; |
||
| 3734 | var recalculateHeightForCells = function (warehouse, heights) { |
||
| 3735 | var all = Warehouse.justCells(warehouse); |
||
| 637 | daniel-mar | 3736 | return map$1(all, function (cell) { |
| 597 | daniel-mar | 3737 | var height = total(cell.row, cell.row + cell.rowspan, heights); |
| 3738 | return { |
||
| 3739 | element: cell.element, |
||
| 3740 | height: height, |
||
| 3741 | rowspan: cell.rowspan |
||
| 3742 | }; |
||
| 3743 | }); |
||
| 3744 | }; |
||
| 3745 | var matchRowHeight = function (warehouse, heights) { |
||
| 637 | daniel-mar | 3746 | return map$1(warehouse.all, function (row, i) { |
| 597 | daniel-mar | 3747 | return { |
| 3748 | element: row.element, |
||
| 3749 | height: heights[i] |
||
| 3750 | }; |
||
| 3751 | }); |
||
| 3752 | }; |
||
| 3753 | |||
| 3754 | var sumUp = function (newSize) { |
||
| 3755 | return foldr(newSize, function (b, a) { |
||
| 3756 | return b + a; |
||
| 3757 | }, 0); |
||
| 3758 | }; |
||
| 3759 | var recalculate = function (warehouse, widths) { |
||
| 3760 | if (Warehouse.hasColumns(warehouse)) { |
||
| 3761 | return recalculateWidthForColumns(warehouse, widths); |
||
| 3762 | } else { |
||
| 3763 | return recalculateWidthForCells(warehouse, widths); |
||
| 3764 | } |
||
| 3765 | }; |
||
| 3766 | var recalculateAndApply = function (warehouse, widths, tableSize) { |
||
| 3767 | var newSizes = recalculate(warehouse, widths); |
||
| 637 | daniel-mar | 3768 | each$2(newSizes, function (cell) { |
| 597 | daniel-mar | 3769 | tableSize.setElementWidth(cell.element, cell.width); |
| 3770 | }); |
||
| 3771 | }; |
||
| 3772 | var adjustWidth = function (table, delta, index, resizing, tableSize) { |
||
| 3773 | var warehouse = Warehouse.fromTable(table); |
||
| 3774 | var step = tableSize.getCellDelta(delta); |
||
| 3775 | var widths = tableSize.getWidths(warehouse, tableSize); |
||
| 3776 | var isLastColumn = index === warehouse.grid.columns - 1; |
||
| 3777 | var clampedStep = resizing.clampTableDelta(widths, index, step, tableSize.minCellWidth(), isLastColumn); |
||
| 3778 | var deltas = determine(widths, index, clampedStep, tableSize, resizing); |
||
| 637 | daniel-mar | 3779 | var newWidths = map$1(deltas, function (dx, i) { |
| 597 | daniel-mar | 3780 | return dx + widths[i]; |
| 3781 | }); |
||
| 3782 | recalculateAndApply(warehouse, newWidths, tableSize); |
||
| 3783 | resizing.resizeTable(tableSize.adjustTableWidth, clampedStep, isLastColumn); |
||
| 3784 | }; |
||
| 3785 | var adjustHeight = function (table, delta, index, direction) { |
||
| 3786 | var warehouse = Warehouse.fromTable(table); |
||
| 3787 | var heights = getPixelHeights(warehouse, table, direction); |
||
| 637 | daniel-mar | 3788 | var newHeights = map$1(heights, function (dy, i) { |
| 597 | daniel-mar | 3789 | return index === i ? Math.max(delta + dy, minHeight()) : dy; |
| 3790 | }); |
||
| 3791 | var newCellSizes = recalculateHeightForCells(warehouse, newHeights); |
||
| 3792 | var newRowSizes = matchRowHeight(warehouse, newHeights); |
||
| 637 | daniel-mar | 3793 | each$2(newRowSizes, function (row) { |
| 597 | daniel-mar | 3794 | setHeight(row.element, row.height); |
| 3795 | }); |
||
| 637 | daniel-mar | 3796 | each$2(newCellSizes, function (cell) { |
| 597 | daniel-mar | 3797 | setHeight(cell.element, cell.height); |
| 3798 | }); |
||
| 3799 | var total = sumUp(newHeights); |
||
| 3800 | setHeight(table, total); |
||
| 3801 | }; |
||
| 637 | daniel-mar | 3802 | var adjustAndRedistributeWidths$1 = function (_table, list, details, tableSize, resizeBehaviour) { |
| 597 | daniel-mar | 3803 | var warehouse = Warehouse.generate(list); |
| 3804 | var sizes = tableSize.getWidths(warehouse, tableSize); |
||
| 3805 | var tablePixelWidth = tableSize.pixelWidth(); |
||
| 3806 | var _a = resizeBehaviour.calcRedestributedWidths(sizes, tablePixelWidth, details.pixelDelta, tableSize.isRelative), newSizes = _a.newSizes, delta = _a.delta; |
||
| 3807 | recalculateAndApply(warehouse, newSizes, tableSize); |
||
| 3808 | tableSize.adjustTableWidth(delta); |
||
| 3809 | }; |
||
| 3810 | var adjustWidthTo = function (_table, list, _info, tableSize) { |
||
| 3811 | var warehouse = Warehouse.generate(list); |
||
| 3812 | var widths = tableSize.getWidths(warehouse, tableSize); |
||
| 3813 | recalculateAndApply(warehouse, widths, tableSize); |
||
| 3814 | }; |
||
| 3815 | |||
| 3816 | var zero = function (array) { |
||
| 637 | daniel-mar | 3817 | return map$1(array, constant(0)); |
| 597 | daniel-mar | 3818 | }; |
| 3819 | var surround = function (sizes, startIndex, endIndex, results, f) { |
||
| 3820 | return f(sizes.slice(0, startIndex)).concat(results).concat(f(sizes.slice(endIndex))); |
||
| 3821 | }; |
||
| 3822 | var clampDeltaHelper = function (predicate) { |
||
| 3823 | return function (sizes, index, delta, minCellSize) { |
||
| 3824 | if (!predicate(delta)) { |
||
| 3825 | return delta; |
||
| 3826 | } else { |
||
| 3827 | var newSize = Math.max(minCellSize, sizes[index] - Math.abs(delta)); |
||
| 3828 | var diff = Math.abs(newSize - sizes[index]); |
||
| 3829 | return delta >= 0 ? diff : -diff; |
||
| 3830 | } |
||
| 3831 | }; |
||
| 3832 | }; |
||
| 3833 | var clampNegativeDelta = clampDeltaHelper(function (delta) { |
||
| 3834 | return delta < 0; |
||
| 3835 | }); |
||
| 3836 | var clampDelta = clampDeltaHelper(always); |
||
| 3837 | var resizeTable = function () { |
||
| 3838 | var calcFixedDeltas = function (sizes, index, next, delta, minCellSize) { |
||
| 3839 | var clampedDelta = clampNegativeDelta(sizes, index, delta, minCellSize); |
||
| 3840 | return surround(sizes, index, next + 1, [ |
||
| 3841 | clampedDelta, |
||
| 3842 | |||
| 3843 | ], zero); |
||
| 3844 | }; |
||
| 3845 | var calcRelativeDeltas = function (sizes, index, delta, minCellSize) { |
||
| 3846 | var ratio = (100 + delta) / 100; |
||
| 3847 | var newThis = Math.max(minCellSize, (sizes[index] + delta) / ratio); |
||
| 637 | daniel-mar | 3848 | return map$1(sizes, function (size, idx) { |
| 597 | daniel-mar | 3849 | var newSize = idx === index ? newThis : size / ratio; |
| 3850 | return newSize - size; |
||
| 3851 | }); |
||
| 3852 | }; |
||
| 3853 | var calcLeftEdgeDeltas = function (sizes, index, next, delta, minCellSize, isRelative) { |
||
| 3854 | if (isRelative) { |
||
| 3855 | return calcRelativeDeltas(sizes, index, delta, minCellSize); |
||
| 3856 | } else { |
||
| 3857 | return calcFixedDeltas(sizes, index, next, delta, minCellSize); |
||
| 3858 | } |
||
| 3859 | }; |
||
| 3860 | var calcMiddleDeltas = function (sizes, _prev, index, next, delta, minCellSize, isRelative) { |
||
| 3861 | return calcLeftEdgeDeltas(sizes, index, next, delta, minCellSize, isRelative); |
||
| 3862 | }; |
||
| 3863 | var resizeTable = function (resizer, delta) { |
||
| 3864 | return resizer(delta); |
||
| 3865 | }; |
||
| 3866 | var calcRightEdgeDeltas = function (sizes, _prev, index, delta, minCellSize, isRelative) { |
||
| 3867 | if (isRelative) { |
||
| 3868 | return calcRelativeDeltas(sizes, index, delta, minCellSize); |
||
| 3869 | } else { |
||
| 3870 | var clampedDelta = clampNegativeDelta(sizes, index, delta, minCellSize); |
||
| 3871 | return zero(sizes.slice(0, index)).concat([clampedDelta]); |
||
| 3872 | } |
||
| 3873 | }; |
||
| 3874 | var calcRedestributedWidths = function (sizes, totalWidth, pixelDelta, isRelative) { |
||
| 3875 | if (isRelative) { |
||
| 3876 | var tableWidth = totalWidth + pixelDelta; |
||
| 3877 | var ratio_1 = tableWidth / totalWidth; |
||
| 637 | daniel-mar | 3878 | var newSizes = map$1(sizes, function (size) { |
| 597 | daniel-mar | 3879 | return size / ratio_1; |
| 3880 | }); |
||
| 3881 | return { |
||
| 3882 | delta: ratio_1 * 100 - 100, |
||
| 3883 | newSizes: newSizes |
||
| 3884 | }; |
||
| 3885 | } else { |
||
| 3886 | return { |
||
| 3887 | delta: pixelDelta, |
||
| 3888 | newSizes: sizes |
||
| 3889 | }; |
||
| 3890 | } |
||
| 3891 | }; |
||
| 3892 | return { |
||
| 3893 | resizeTable: resizeTable, |
||
| 3894 | clampTableDelta: clampNegativeDelta, |
||
| 3895 | calcLeftEdgeDeltas: calcLeftEdgeDeltas, |
||
| 3896 | calcMiddleDeltas: calcMiddleDeltas, |
||
| 3897 | calcRightEdgeDeltas: calcRightEdgeDeltas, |
||
| 3898 | calcRedestributedWidths: calcRedestributedWidths |
||
| 3899 | }; |
||
| 3900 | }; |
||
| 3901 | var preserveTable = function () { |
||
| 3902 | var calcLeftEdgeDeltas = function (sizes, index, next, delta, minCellSize) { |
||
| 3903 | var idx = delta >= 0 ? next : index; |
||
| 3904 | var clampedDelta = clampDelta(sizes, idx, delta, minCellSize); |
||
| 3905 | return surround(sizes, index, next + 1, [ |
||
| 3906 | clampedDelta, |
||
| 3907 | -clampedDelta |
||
| 3908 | ], zero); |
||
| 3909 | }; |
||
| 3910 | var calcMiddleDeltas = function (sizes, _prev, index, next, delta, minCellSize) { |
||
| 3911 | return calcLeftEdgeDeltas(sizes, index, next, delta, minCellSize); |
||
| 3912 | }; |
||
| 3913 | var resizeTable = function (resizer, delta, isLastColumn) { |
||
| 3914 | if (isLastColumn) { |
||
| 3915 | resizer(delta); |
||
| 3916 | } |
||
| 3917 | }; |
||
| 3918 | var calcRightEdgeDeltas = function (sizes, _prev, _index, delta, _minCellSize, isRelative) { |
||
| 3919 | if (isRelative) { |
||
| 3920 | return zero(sizes); |
||
| 3921 | } else { |
||
| 3922 | var diff = delta / sizes.length; |
||
| 637 | daniel-mar | 3923 | return map$1(sizes, constant(diff)); |
| 597 | daniel-mar | 3924 | } |
| 3925 | }; |
||
| 3926 | var clampTableDelta = function (sizes, index, delta, minCellSize, isLastColumn) { |
||
| 3927 | if (isLastColumn) { |
||
| 3928 | if (delta >= 0) { |
||
| 3929 | return delta; |
||
| 3930 | } else { |
||
| 3931 | var maxDelta = foldl(sizes, function (a, b) { |
||
| 3932 | return a + b - minCellSize; |
||
| 3933 | }, 0); |
||
| 3934 | return Math.max(-maxDelta, delta); |
||
| 3935 | } |
||
| 3936 | } else { |
||
| 3937 | return clampNegativeDelta(sizes, index, delta, minCellSize); |
||
| 3938 | } |
||
| 3939 | }; |
||
| 3940 | var calcRedestributedWidths = function (sizes, _totalWidth, _pixelDelta, _isRelative) { |
||
| 3941 | return { |
||
| 3942 | delta: 0, |
||
| 3943 | newSizes: sizes |
||
| 3944 | }; |
||
| 3945 | }; |
||
| 3946 | return { |
||
| 3947 | resizeTable: resizeTable, |
||
| 3948 | clampTableDelta: clampTableDelta, |
||
| 3949 | calcLeftEdgeDeltas: calcLeftEdgeDeltas, |
||
| 3950 | calcMiddleDeltas: calcMiddleDeltas, |
||
| 3951 | calcRightEdgeDeltas: calcRightEdgeDeltas, |
||
| 3952 | calcRedestributedWidths: calcRedestributedWidths |
||
| 3953 | }; |
||
| 3954 | }; |
||
| 3955 | |||
| 3956 | var only = function (element, isResizable) { |
||
| 3957 | var parent = Optional.from(element.dom.documentElement).map(SugarElement.fromDom).getOr(element); |
||
| 3958 | return { |
||
| 3959 | parent: constant(parent), |
||
| 3960 | view: constant(element), |
||
| 3961 | origin: constant(SugarPosition(0, 0)), |
||
| 3962 | isResizable: isResizable |
||
| 3963 | }; |
||
| 3964 | }; |
||
| 3965 | var detached = function (editable, chrome, isResizable) { |
||
| 3966 | var origin = function () { |
||
| 3967 | return absolute(chrome); |
||
| 3968 | }; |
||
| 3969 | return { |
||
| 3970 | parent: constant(chrome), |
||
| 3971 | view: constant(editable), |
||
| 3972 | origin: origin, |
||
| 3973 | isResizable: isResizable |
||
| 3974 | }; |
||
| 3975 | }; |
||
| 637 | daniel-mar | 3976 | var body = function (editable, chrome, isResizable) { |
| 597 | daniel-mar | 3977 | return { |
| 3978 | parent: constant(chrome), |
||
| 3979 | view: constant(editable), |
||
| 3980 | origin: constant(SugarPosition(0, 0)), |
||
| 3981 | isResizable: isResizable |
||
| 3982 | }; |
||
| 3983 | }; |
||
| 3984 | var ResizeWire = { |
||
| 3985 | only: only, |
||
| 3986 | detached: detached, |
||
| 637 | daniel-mar | 3987 | body: body |
| 597 | daniel-mar | 3988 | }; |
| 3989 | |||
| 637 | daniel-mar | 3990 | var adt$6 = Adt.generate([ |
| 597 | daniel-mar | 3991 | { invalid: ['raw'] }, |
| 3992 | { pixels: ['value'] }, |
||
| 3993 | { percent: ['value'] } |
||
| 3994 | ]); |
||
| 3995 | var validateFor = function (suffix, type, value) { |
||
| 3996 | var rawAmount = value.substring(0, value.length - suffix.length); |
||
| 3997 | var amount = parseFloat(rawAmount); |
||
| 637 | daniel-mar | 3998 | return rawAmount === amount.toString() ? type(amount) : adt$6.invalid(value); |
| 597 | daniel-mar | 3999 | }; |
| 637 | daniel-mar | 4000 | var from = function (value) { |
| 597 | daniel-mar | 4001 | if (endsWith(value, '%')) { |
| 637 | daniel-mar | 4002 | return validateFor('%', adt$6.percent, value); |
| 597 | daniel-mar | 4003 | } |
| 4004 | if (endsWith(value, 'px')) { |
||
| 637 | daniel-mar | 4005 | return validateFor('px', adt$6.pixels, value); |
| 597 | daniel-mar | 4006 | } |
| 637 | daniel-mar | 4007 | return adt$6.invalid(value); |
| 597 | daniel-mar | 4008 | }; |
| 637 | daniel-mar | 4009 | var Size = __assign(__assign({}, adt$6), { from: from }); |
| 597 | daniel-mar | 4010 | |
| 4011 | var redistributeToPercent = function (widths, totalWidth) { |
||
| 637 | daniel-mar | 4012 | return map$1(widths, function (w) { |
| 597 | daniel-mar | 4013 | var colType = Size.from(w); |
| 4014 | return colType.fold(function () { |
||
| 4015 | return w; |
||
| 4016 | }, function (px) { |
||
| 4017 | var ratio = px / totalWidth * 100; |
||
| 4018 | return ratio + '%'; |
||
| 4019 | }, function (pc) { |
||
| 4020 | return pc + '%'; |
||
| 4021 | }); |
||
| 4022 | }); |
||
| 4023 | }; |
||
| 4024 | var redistributeToPx = function (widths, totalWidth, newTotalWidth) { |
||
| 4025 | var scale = newTotalWidth / totalWidth; |
||
| 637 | daniel-mar | 4026 | return map$1(widths, function (w) { |
| 597 | daniel-mar | 4027 | var colType = Size.from(w); |
| 4028 | return colType.fold(function () { |
||
| 4029 | return w; |
||
| 4030 | }, function (px) { |
||
| 4031 | return px * scale + 'px'; |
||
| 4032 | }, function (pc) { |
||
| 4033 | return pc / 100 * newTotalWidth + 'px'; |
||
| 4034 | }); |
||
| 4035 | }); |
||
| 4036 | }; |
||
| 4037 | var redistributeEmpty = function (newWidthType, columns) { |
||
| 4038 | var f = newWidthType.fold(function () { |
||
| 4039 | return constant(''); |
||
| 4040 | }, function (pixels) { |
||
| 4041 | var num = pixels / columns; |
||
| 4042 | return constant(num + 'px'); |
||
| 4043 | }, function () { |
||
| 4044 | var num = 100 / columns; |
||
| 4045 | return constant(num + '%'); |
||
| 4046 | }); |
||
| 637 | daniel-mar | 4047 | return range$1(columns, f); |
| 597 | daniel-mar | 4048 | }; |
| 4049 | var redistributeValues = function (newWidthType, widths, totalWidth) { |
||
| 4050 | return newWidthType.fold(function () { |
||
| 4051 | return widths; |
||
| 4052 | }, function (px) { |
||
| 4053 | return redistributeToPx(widths, totalWidth, px); |
||
| 4054 | }, function (_pc) { |
||
| 4055 | return redistributeToPercent(widths, totalWidth); |
||
| 4056 | }); |
||
| 4057 | }; |
||
| 637 | daniel-mar | 4058 | var redistribute$1 = function (widths, totalWidth, newWidth) { |
| 597 | daniel-mar | 4059 | var newType = Size.from(newWidth); |
| 4060 | var floats = forall(widths, function (s) { |
||
| 4061 | return s === '0px'; |
||
| 4062 | }) ? redistributeEmpty(newType, widths.length) : redistributeValues(newType, widths, totalWidth); |
||
| 4063 | return normalize(floats); |
||
| 4064 | }; |
||
| 4065 | var sum = function (values, fallback) { |
||
| 4066 | if (values.length === 0) { |
||
| 4067 | return fallback; |
||
| 4068 | } |
||
| 4069 | return foldr(values, function (rest, v) { |
||
| 4070 | return Size.from(v).fold(constant(0), identity, identity) + rest; |
||
| 4071 | }, 0); |
||
| 4072 | }; |
||
| 4073 | var roundDown = function (num, unit) { |
||
| 4074 | var floored = Math.floor(num); |
||
| 4075 | return { |
||
| 4076 | value: floored + unit, |
||
| 4077 | remainder: num - floored |
||
| 4078 | }; |
||
| 4079 | }; |
||
| 637 | daniel-mar | 4080 | var add$3 = function (value, amount) { |
| 597 | daniel-mar | 4081 | return Size.from(value).fold(constant(value), function (px) { |
| 4082 | return px + amount + 'px'; |
||
| 4083 | }, function (pc) { |
||
| 4084 | return pc + amount + '%'; |
||
| 4085 | }); |
||
| 4086 | }; |
||
| 4087 | var normalize = function (values) { |
||
| 4088 | if (values.length === 0) { |
||
| 4089 | return values; |
||
| 4090 | } |
||
| 4091 | var scan = foldr(values, function (rest, value) { |
||
| 4092 | var info = Size.from(value).fold(function () { |
||
| 4093 | return { |
||
| 4094 | value: value, |
||
| 4095 | remainder: 0 |
||
| 4096 | }; |
||
| 4097 | }, function (num) { |
||
| 4098 | return roundDown(num, 'px'); |
||
| 4099 | }, function (num) { |
||
| 4100 | return { |
||
| 4101 | value: num + '%', |
||
| 4102 | remainder: 0 |
||
| 4103 | }; |
||
| 4104 | }); |
||
| 4105 | return { |
||
| 4106 | output: [info.value].concat(rest.output), |
||
| 4107 | remainder: rest.remainder + info.remainder |
||
| 4108 | }; |
||
| 4109 | }, { |
||
| 4110 | output: [], |
||
| 4111 | remainder: 0 |
||
| 4112 | }); |
||
| 4113 | var r = scan.output; |
||
| 637 | daniel-mar | 4114 | return r.slice(0, r.length - 1).concat([add$3(r[r.length - 1], Math.round(scan.remainder))]); |
| 597 | daniel-mar | 4115 | }; |
| 4116 | var validate = Size.from; |
||
| 4117 | |||
| 4118 | var redistributeToW = function (newWidths, cells, unit) { |
||
| 637 | daniel-mar | 4119 | each$2(cells, function (cell) { |
| 597 | daniel-mar | 4120 | var widths = newWidths.slice(cell.column, cell.colspan + cell.column); |
| 4121 | var w = sum(widths, minWidth()); |
||
| 4122 | set$1(cell.element, 'width', w + unit); |
||
| 4123 | }); |
||
| 4124 | }; |
||
| 4125 | var redistributeToColumns = function (newWidths, columns, unit) { |
||
| 637 | daniel-mar | 4126 | each$2(columns, function (column, index) { |
| 597 | daniel-mar | 4127 | var width = sum([newWidths[index]], minWidth()); |
| 4128 | set$1(column.element, 'width', width + unit); |
||
| 4129 | }); |
||
| 4130 | }; |
||
| 4131 | var redistributeToH = function (newHeights, rows, cells, unit) { |
||
| 637 | daniel-mar | 4132 | each$2(cells, function (cell) { |
| 597 | daniel-mar | 4133 | var heights = newHeights.slice(cell.row, cell.rowspan + cell.row); |
| 4134 | var h = sum(heights, minHeight()); |
||
| 4135 | set$1(cell.element, 'height', h + unit); |
||
| 4136 | }); |
||
| 637 | daniel-mar | 4137 | each$2(rows, function (row, i) { |
| 597 | daniel-mar | 4138 | set$1(row.element, 'height', newHeights[i]); |
| 4139 | }); |
||
| 4140 | }; |
||
| 4141 | var getUnit = function (newSize) { |
||
| 4142 | return validate(newSize).fold(constant('px'), constant('px'), constant('%')); |
||
| 4143 | }; |
||
| 679 | daniel-mar | 4144 | var redistribute = function (table, optWidth, optHeight) { |
| 597 | daniel-mar | 4145 | var warehouse = Warehouse.fromTable(table); |
| 4146 | var rows = warehouse.all; |
||
| 4147 | var cells = Warehouse.justCells(warehouse); |
||
| 4148 | var columns = Warehouse.justColumns(warehouse); |
||
| 4149 | optWidth.each(function (newWidth) { |
||
| 4150 | var widthUnit = getUnit(newWidth); |
||
| 637 | daniel-mar | 4151 | var totalWidth = get$8(table); |
| 679 | daniel-mar | 4152 | var oldWidths = getRawWidths(warehouse, table); |
| 637 | daniel-mar | 4153 | var nuWidths = redistribute$1(oldWidths, totalWidth, newWidth); |
| 597 | daniel-mar | 4154 | if (Warehouse.hasColumns(warehouse)) { |
| 4155 | redistributeToColumns(nuWidths, columns, widthUnit); |
||
| 4156 | } else { |
||
| 4157 | redistributeToW(nuWidths, cells, widthUnit); |
||
| 4158 | } |
||
| 4159 | set$1(table, 'width', newWidth); |
||
| 4160 | }); |
||
| 4161 | optHeight.each(function (newHeight) { |
||
| 4162 | var hUnit = getUnit(newHeight); |
||
| 637 | daniel-mar | 4163 | var totalHeight = get$7(table); |
| 597 | daniel-mar | 4164 | var oldHeights = getRawHeights(warehouse, table, height); |
| 637 | daniel-mar | 4165 | var nuHeights = redistribute$1(oldHeights, totalHeight, newHeight); |
| 597 | daniel-mar | 4166 | redistributeToH(nuHeights, rows, cells, hUnit); |
| 4167 | set$1(table, 'height', newHeight); |
||
| 4168 | }); |
||
| 4169 | }; |
||
| 637 | daniel-mar | 4170 | var isPercentSizing = isPercentSizing$1; |
| 4171 | var isPixelSizing = isPixelSizing$1; |
||
| 4172 | var isNoneSizing = isNoneSizing$1; |
||
| 597 | daniel-mar | 4173 | |
| 4174 | var getGridSize = function (table) { |
||
| 4175 | var warehouse = Warehouse.fromTable(table); |
||
| 4176 | return warehouse.grid; |
||
| 4177 | }; |
||
| 4178 | |||
| 4179 | var Event = function (fields) { |
||
| 4180 | var handlers = []; |
||
| 4181 | var bind = function (handler) { |
||
| 4182 | if (handler === undefined) { |
||
| 4183 | throw new Error('Event bind error: undefined handler'); |
||
| 4184 | } |
||
| 4185 | handlers.push(handler); |
||
| 4186 | }; |
||
| 4187 | var unbind = function (handler) { |
||
| 637 | daniel-mar | 4188 | handlers = filter$2(handlers, function (h) { |
| 597 | daniel-mar | 4189 | return h !== handler; |
| 4190 | }); |
||
| 4191 | }; |
||
| 4192 | var trigger = function () { |
||
| 4193 | var args = []; |
||
| 4194 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 4195 | args[_i] = arguments[_i]; |
||
| 4196 | } |
||
| 4197 | var event = {}; |
||
| 637 | daniel-mar | 4198 | each$2(fields, function (name, i) { |
| 597 | daniel-mar | 4199 | event[name] = args[i]; |
| 4200 | }); |
||
| 637 | daniel-mar | 4201 | each$2(handlers, function (handler) { |
| 597 | daniel-mar | 4202 | handler(event); |
| 4203 | }); |
||
| 4204 | }; |
||
| 4205 | return { |
||
| 4206 | bind: bind, |
||
| 4207 | unbind: unbind, |
||
| 4208 | trigger: trigger |
||
| 4209 | }; |
||
| 4210 | }; |
||
| 4211 | |||
| 637 | daniel-mar | 4212 | var create$4 = function (typeDefs) { |
| 4213 | var registry = map(typeDefs, function (event) { |
||
| 597 | daniel-mar | 4214 | return { |
| 4215 | bind: event.bind, |
||
| 4216 | unbind: event.unbind |
||
| 4217 | }; |
||
| 4218 | }); |
||
| 637 | daniel-mar | 4219 | var trigger = map(typeDefs, function (event) { |
| 597 | daniel-mar | 4220 | return event.trigger; |
| 4221 | }); |
||
| 4222 | return { |
||
| 4223 | registry: registry, |
||
| 4224 | trigger: trigger |
||
| 4225 | }; |
||
| 4226 | }; |
||
| 4227 | |||
| 637 | daniel-mar | 4228 | var last = function (fn, rate) { |
| 597 | daniel-mar | 4229 | var timer = null; |
| 4230 | var cancel = function () { |
||
| 637 | daniel-mar | 4231 | if (!isNull(timer)) { |
| 597 | daniel-mar | 4232 | clearTimeout(timer); |
| 4233 | timer = null; |
||
| 4234 | } |
||
| 4235 | }; |
||
| 4236 | var throttle = function () { |
||
| 4237 | var args = []; |
||
| 4238 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 4239 | args[_i] = arguments[_i]; |
||
| 4240 | } |
||
| 637 | daniel-mar | 4241 | cancel(); |
| 597 | daniel-mar | 4242 | timer = setTimeout(function () { |
| 637 | daniel-mar | 4243 | timer = null; |
| 597 | daniel-mar | 4244 | fn.apply(null, args); |
| 4245 | }, rate); |
||
| 4246 | }; |
||
| 4247 | return { |
||
| 4248 | cancel: cancel, |
||
| 4249 | throttle: throttle |
||
| 4250 | }; |
||
| 4251 | }; |
||
| 4252 | |||
| 637 | daniel-mar | 4253 | var sort = function (arr) { |
| 597 | daniel-mar | 4254 | return arr.slice(0).sort(); |
| 4255 | }; |
||
| 4256 | var reqMessage = function (required, keys) { |
||
| 637 | daniel-mar | 4257 | throw new Error('All required keys (' + sort(required).join(', ') + ') were not specified. Specified keys were: ' + sort(keys).join(', ') + '.'); |
| 597 | daniel-mar | 4258 | }; |
| 4259 | var unsuppMessage = function (unsupported) { |
||
| 637 | daniel-mar | 4260 | throw new Error('Unsupported keys for object: ' + sort(unsupported).join(', ')); |
| 597 | daniel-mar | 4261 | }; |
| 4262 | var validateStrArr = function (label, array) { |
||
| 4263 | if (!isArray(array)) { |
||
| 4264 | throw new Error('The ' + label + ' fields must be an array. Was: ' + array + '.'); |
||
| 4265 | } |
||
| 637 | daniel-mar | 4266 | each$2(array, function (a) { |
| 597 | daniel-mar | 4267 | if (!isString(a)) { |
| 4268 | throw new Error('The value ' + a + ' in the ' + label + ' fields was not a string.'); |
||
| 4269 | } |
||
| 4270 | }); |
||
| 4271 | }; |
||
| 4272 | var invalidTypeMessage = function (incorrect, type) { |
||
| 637 | daniel-mar | 4273 | throw new Error('All values need to be of type: ' + type + '. Keys (' + sort(incorrect).join(', ') + ') were not.'); |
| 597 | daniel-mar | 4274 | }; |
| 4275 | var checkDupes = function (everything) { |
||
| 637 | daniel-mar | 4276 | var sorted = sort(everything); |
| 4277 | var dupe = find$1(sorted, function (s, i) { |
||
| 597 | daniel-mar | 4278 | return i < sorted.length - 1 && s === sorted[i + 1]; |
| 4279 | }); |
||
| 4280 | dupe.each(function (d) { |
||
| 4281 | throw new Error('The field: ' + d + ' occurs more than once in the combined fields: [' + sorted.join(', ') + '].'); |
||
| 4282 | }); |
||
| 4283 | }; |
||
| 4284 | |||
| 4285 | var base = function (handleUnsupported, required) { |
||
| 4286 | return baseWith(handleUnsupported, required, { |
||
| 4287 | validate: isFunction, |
||
| 4288 | label: 'function' |
||
| 4289 | }); |
||
| 4290 | }; |
||
| 4291 | var baseWith = function (handleUnsupported, required, pred) { |
||
| 4292 | if (required.length === 0) { |
||
| 4293 | throw new Error('You must specify at least one required field.'); |
||
| 4294 | } |
||
| 4295 | validateStrArr('required', required); |
||
| 4296 | checkDupes(required); |
||
| 4297 | return function (obj) { |
||
| 4298 | var keys$1 = keys(obj); |
||
| 4299 | var allReqd = forall(required, function (req) { |
||
| 637 | daniel-mar | 4300 | return contains$2(keys$1, req); |
| 597 | daniel-mar | 4301 | }); |
| 4302 | if (!allReqd) { |
||
| 4303 | reqMessage(required, keys$1); |
||
| 4304 | } |
||
| 4305 | handleUnsupported(required, keys$1); |
||
| 637 | daniel-mar | 4306 | var invalidKeys = filter$2(required, function (key) { |
| 597 | daniel-mar | 4307 | return !pred.validate(obj[key], key); |
| 4308 | }); |
||
| 4309 | if (invalidKeys.length > 0) { |
||
| 4310 | invalidTypeMessage(invalidKeys, pred.label); |
||
| 4311 | } |
||
| 4312 | return obj; |
||
| 4313 | }; |
||
| 4314 | }; |
||
| 4315 | var handleExact = function (required, keys) { |
||
| 637 | daniel-mar | 4316 | var unsupported = filter$2(keys, function (key) { |
| 4317 | return !contains$2(required, key); |
||
| 597 | daniel-mar | 4318 | }); |
| 4319 | if (unsupported.length > 0) { |
||
| 4320 | unsuppMessage(unsupported); |
||
| 4321 | } |
||
| 4322 | }; |
||
| 4323 | var exactly = function (required) { |
||
| 4324 | return base(handleExact, required); |
||
| 4325 | }; |
||
| 4326 | |||
| 4327 | var DragMode = exactly([ |
||
| 4328 | 'compare', |
||
| 4329 | 'extract', |
||
| 4330 | 'mutate', |
||
| 4331 | 'sink' |
||
| 4332 | ]); |
||
| 4333 | var DragSink = exactly([ |
||
| 4334 | 'element', |
||
| 4335 | 'start', |
||
| 4336 | 'stop', |
||
| 4337 | 'destroy' |
||
| 4338 | ]); |
||
| 4339 | var DragApi = exactly([ |
||
| 4340 | 'forceDrop', |
||
| 4341 | 'drop', |
||
| 4342 | 'move', |
||
| 4343 | 'delayDrop' |
||
| 4344 | ]); |
||
| 4345 | |||
| 4346 | var InDrag = function () { |
||
| 4347 | var previous = Optional.none(); |
||
| 4348 | var reset = function () { |
||
| 4349 | previous = Optional.none(); |
||
| 4350 | }; |
||
| 4351 | var update = function (mode, nu) { |
||
| 4352 | var result = previous.map(function (old) { |
||
| 4353 | return mode.compare(old, nu); |
||
| 4354 | }); |
||
| 4355 | previous = Optional.some(nu); |
||
| 4356 | return result; |
||
| 4357 | }; |
||
| 4358 | var onEvent = function (event, mode) { |
||
| 4359 | var dataOption = mode.extract(event); |
||
| 4360 | dataOption.each(function (data) { |
||
| 4361 | var offset = update(mode, data); |
||
| 4362 | offset.each(function (d) { |
||
| 4363 | events.trigger.move(d); |
||
| 4364 | }); |
||
| 4365 | }); |
||
| 4366 | }; |
||
| 637 | daniel-mar | 4367 | var events = create$4({ move: Event(['info']) }); |
| 597 | daniel-mar | 4368 | return { |
| 4369 | onEvent: onEvent, |
||
| 4370 | reset: reset, |
||
| 4371 | events: events.registry |
||
| 4372 | }; |
||
| 4373 | }; |
||
| 4374 | |||
| 4375 | var NoDrag = function () { |
||
| 637 | daniel-mar | 4376 | var events = create$4({ move: Event(['info']) }); |
| 597 | daniel-mar | 4377 | return { |
| 4378 | onEvent: noop, |
||
| 4379 | reset: noop, |
||
| 4380 | events: events.registry |
||
| 4381 | }; |
||
| 4382 | }; |
||
| 4383 | |||
| 4384 | var Movement = function () { |
||
| 4385 | var noDragState = NoDrag(); |
||
| 4386 | var inDragState = InDrag(); |
||
| 4387 | var dragState = noDragState; |
||
| 4388 | var on = function () { |
||
| 4389 | dragState.reset(); |
||
| 4390 | dragState = inDragState; |
||
| 4391 | }; |
||
| 4392 | var off = function () { |
||
| 4393 | dragState.reset(); |
||
| 4394 | dragState = noDragState; |
||
| 4395 | }; |
||
| 4396 | var onEvent = function (event, mode) { |
||
| 4397 | dragState.onEvent(event, mode); |
||
| 4398 | }; |
||
| 4399 | var isOn = function () { |
||
| 4400 | return dragState === inDragState; |
||
| 4401 | }; |
||
| 4402 | return { |
||
| 4403 | on: on, |
||
| 4404 | off: off, |
||
| 4405 | isOn: isOn, |
||
| 4406 | onEvent: onEvent, |
||
| 4407 | events: inDragState.events |
||
| 4408 | }; |
||
| 4409 | }; |
||
| 4410 | |||
| 4411 | var setup = function (mutation, mode, settings) { |
||
| 4412 | var active = false; |
||
| 637 | daniel-mar | 4413 | var events = create$4({ |
| 597 | daniel-mar | 4414 | start: Event([]), |
| 4415 | stop: Event([]) |
||
| 4416 | }); |
||
| 4417 | var movement = Movement(); |
||
| 4418 | var drop = function () { |
||
| 4419 | sink.stop(); |
||
| 4420 | if (movement.isOn()) { |
||
| 4421 | movement.off(); |
||
| 4422 | events.trigger.stop(); |
||
| 4423 | } |
||
| 4424 | }; |
||
| 637 | daniel-mar | 4425 | var throttledDrop = last(drop, 200); |
| 597 | daniel-mar | 4426 | var go = function (parent) { |
| 4427 | sink.start(parent); |
||
| 4428 | movement.on(); |
||
| 4429 | events.trigger.start(); |
||
| 4430 | }; |
||
| 4431 | var mousemove = function (event) { |
||
| 4432 | throttledDrop.cancel(); |
||
| 4433 | movement.onEvent(event, mode); |
||
| 4434 | }; |
||
| 4435 | movement.events.move.bind(function (event) { |
||
| 4436 | mode.mutate(mutation, event.info); |
||
| 4437 | }); |
||
| 4438 | var on = function () { |
||
| 4439 | active = true; |
||
| 4440 | }; |
||
| 4441 | var off = function () { |
||
| 4442 | active = false; |
||
| 4443 | }; |
||
| 4444 | var runIfActive = function (f) { |
||
| 4445 | return function () { |
||
| 4446 | var args = []; |
||
| 4447 | for (var _i = 0; _i < arguments.length; _i++) { |
||
| 4448 | args[_i] = arguments[_i]; |
||
| 4449 | } |
||
| 4450 | if (active) { |
||
| 4451 | f.apply(null, args); |
||
| 4452 | } |
||
| 4453 | }; |
||
| 4454 | }; |
||
| 4455 | var sink = mode.sink(DragApi({ |
||
| 4456 | forceDrop: drop, |
||
| 4457 | drop: runIfActive(drop), |
||
| 4458 | move: runIfActive(mousemove), |
||
| 4459 | delayDrop: runIfActive(throttledDrop.throttle) |
||
| 4460 | }), settings); |
||
| 4461 | var destroy = function () { |
||
| 4462 | sink.destroy(); |
||
| 4463 | }; |
||
| 4464 | return { |
||
| 4465 | element: sink.element, |
||
| 4466 | go: go, |
||
| 4467 | on: on, |
||
| 4468 | off: off, |
||
| 4469 | destroy: destroy, |
||
| 4470 | events: events.registry |
||
| 4471 | }; |
||
| 4472 | }; |
||
| 4473 | |||
| 4474 | var mkEvent = function (target, x, y, stop, prevent, kill, raw) { |
||
| 4475 | return { |
||
| 4476 | target: target, |
||
| 4477 | x: x, |
||
| 4478 | y: y, |
||
| 4479 | stop: stop, |
||
| 4480 | prevent: prevent, |
||
| 4481 | kill: kill, |
||
| 4482 | raw: raw |
||
| 4483 | }; |
||
| 4484 | }; |
||
| 637 | daniel-mar | 4485 | var fromRawEvent$1 = function (rawEvent) { |
| 597 | daniel-mar | 4486 | var target = SugarElement.fromDom(getOriginalEventTarget(rawEvent).getOr(rawEvent.target)); |
| 4487 | var stop = function () { |
||
| 4488 | return rawEvent.stopPropagation(); |
||
| 4489 | }; |
||
| 4490 | var prevent = function () { |
||
| 4491 | return rawEvent.preventDefault(); |
||
| 4492 | }; |
||
| 4493 | var kill = compose(prevent, stop); |
||
| 4494 | return mkEvent(target, rawEvent.clientX, rawEvent.clientY, stop, prevent, kill, rawEvent); |
||
| 4495 | }; |
||
| 637 | daniel-mar | 4496 | var handle$2 = function (filter, handler) { |
| 597 | daniel-mar | 4497 | return function (rawEvent) { |
| 4498 | if (filter(rawEvent)) { |
||
| 637 | daniel-mar | 4499 | handler(fromRawEvent$1(rawEvent)); |
| 597 | daniel-mar | 4500 | } |
| 4501 | }; |
||
| 4502 | }; |
||
| 4503 | var binder = function (element, event, filter, handler, useCapture) { |
||
| 637 | daniel-mar | 4504 | var wrapped = handle$2(filter, handler); |
| 597 | daniel-mar | 4505 | element.dom.addEventListener(event, wrapped, useCapture); |
| 4506 | return { unbind: curry(unbind, element, event, wrapped, useCapture) }; |
||
| 4507 | }; |
||
| 4508 | var bind$1 = function (element, event, filter, handler) { |
||
| 4509 | return binder(element, event, filter, handler, false); |
||
| 4510 | }; |
||
| 4511 | var unbind = function (element, event, handler, useCapture) { |
||
| 4512 | element.dom.removeEventListener(event, handler, useCapture); |
||
| 4513 | }; |
||
| 4514 | |||
| 637 | daniel-mar | 4515 | var filter = always; |
| 4516 | var bind = function (element, event, handler) { |
||
| 4517 | return bind$1(element, event, filter, handler); |
||
| 597 | daniel-mar | 4518 | }; |
| 637 | daniel-mar | 4519 | var fromRawEvent = fromRawEvent$1; |
| 597 | daniel-mar | 4520 | |
| 4521 | var read = function (element, attr) { |
||
| 637 | daniel-mar | 4522 | var value = get$b(element, attr); |
| 597 | daniel-mar | 4523 | return value === undefined || value === '' ? [] : value.split(' '); |
| 4524 | }; |
||
| 637 | daniel-mar | 4525 | var add$2 = function (element, attr, id) { |
| 597 | daniel-mar | 4526 | var old = read(element, attr); |
| 4527 | var nu = old.concat([id]); |
||
| 637 | daniel-mar | 4528 | set$2(element, attr, nu.join(' ')); |
| 597 | daniel-mar | 4529 | return true; |
| 4530 | }; |
||
| 637 | daniel-mar | 4531 | var remove$4 = function (element, attr, id) { |
| 4532 | var nu = filter$2(read(element, attr), function (v) { |
||
| 597 | daniel-mar | 4533 | return v !== id; |
| 4534 | }); |
||
| 4535 | if (nu.length > 0) { |
||
| 637 | daniel-mar | 4536 | set$2(element, attr, nu.join(' ')); |
| 597 | daniel-mar | 4537 | } else { |
| 637 | daniel-mar | 4538 | remove$7(element, attr); |
| 597 | daniel-mar | 4539 | } |
| 4540 | return false; |
||
| 4541 | }; |
||
| 4542 | |||
| 4543 | var supports = function (element) { |
||
| 4544 | return element.dom.classList !== undefined; |
||
| 4545 | }; |
||
| 637 | daniel-mar | 4546 | var get$5 = function (element) { |
| 597 | daniel-mar | 4547 | return read(element, 'class'); |
| 4548 | }; |
||
| 637 | daniel-mar | 4549 | var add$1 = function (element, clazz) { |
| 4550 | return add$2(element, 'class', clazz); |
||
| 597 | daniel-mar | 4551 | }; |
| 637 | daniel-mar | 4552 | var remove$3 = function (element, clazz) { |
| 4553 | return remove$4(element, 'class', clazz); |
||
| 597 | daniel-mar | 4554 | }; |
| 4555 | |||
| 637 | daniel-mar | 4556 | var add = function (element, clazz) { |
| 597 | daniel-mar | 4557 | if (supports(element)) { |
| 4558 | element.dom.classList.add(clazz); |
||
| 4559 | } else { |
||
| 637 | daniel-mar | 4560 | add$1(element, clazz); |
| 597 | daniel-mar | 4561 | } |
| 4562 | }; |
||
| 4563 | var cleanClass = function (element) { |
||
| 637 | daniel-mar | 4564 | var classList = supports(element) ? element.dom.classList : get$5(element); |
| 597 | daniel-mar | 4565 | if (classList.length === 0) { |
| 637 | daniel-mar | 4566 | remove$7(element, 'class'); |
| 597 | daniel-mar | 4567 | } |
| 4568 | }; |
||
| 637 | daniel-mar | 4569 | var remove$2 = function (element, clazz) { |
| 597 | daniel-mar | 4570 | if (supports(element)) { |
| 4571 | var classList = element.dom.classList; |
||
| 4572 | classList.remove(clazz); |
||
| 4573 | } else { |
||
| 637 | daniel-mar | 4574 | remove$3(element, clazz); |
| 597 | daniel-mar | 4575 | } |
| 4576 | cleanClass(element); |
||
| 4577 | }; |
||
| 637 | daniel-mar | 4578 | var has = function (element, clazz) { |
| 597 | daniel-mar | 4579 | return supports(element) && element.dom.classList.contains(clazz); |
| 4580 | }; |
||
| 4581 | |||
| 4582 | var css = function (namespace) { |
||
| 4583 | var dashNamespace = namespace.replace(/\./g, '-'); |
||
| 4584 | var resolve = function (str) { |
||
| 4585 | return dashNamespace + '-' + str; |
||
| 4586 | }; |
||
| 4587 | return { resolve: resolve }; |
||
| 4588 | }; |
||
| 4589 | |||
| 637 | daniel-mar | 4590 | var styles$1 = css('ephox-dragster'); |
| 4591 | var resolve$1 = styles$1.resolve; |
||
| 597 | daniel-mar | 4592 | |
| 4593 | var Blocker = function (options) { |
||
| 637 | daniel-mar | 4594 | var settings = __assign({ layerClass: resolve$1('blocker') }, options); |
| 597 | daniel-mar | 4595 | var div = SugarElement.fromTag('div'); |
| 637 | daniel-mar | 4596 | set$2(div, 'role', 'presentation'); |
| 4597 | setAll(div, { |
||
| 597 | daniel-mar | 4598 | position: 'fixed', |
| 4599 | left: '0px', |
||
| 4600 | top: '0px', |
||
| 4601 | width: '100%', |
||
| 4602 | height: '100%' |
||
| 4603 | }); |
||
| 637 | daniel-mar | 4604 | add(div, resolve$1('blocker')); |
| 4605 | add(div, settings.layerClass); |
||
| 4606 | var element = constant(div); |
||
| 597 | daniel-mar | 4607 | var destroy = function () { |
| 637 | daniel-mar | 4608 | remove$5(div); |
| 597 | daniel-mar | 4609 | }; |
| 4610 | return { |
||
| 4611 | element: element, |
||
| 4612 | destroy: destroy |
||
| 4613 | }; |
||
| 4614 | }; |
||
| 4615 | |||
| 4616 | var compare = function (old, nu) { |
||
| 4617 | return SugarPosition(nu.left - old.left, nu.top - old.top); |
||
| 4618 | }; |
||
| 637 | daniel-mar | 4619 | var extract = function (event) { |
| 597 | daniel-mar | 4620 | return Optional.some(SugarPosition(event.x, event.y)); |
| 4621 | }; |
||
| 4622 | var mutate = function (mutation, info) { |
||
| 4623 | mutation.mutate(info.left, info.top); |
||
| 4624 | }; |
||
| 4625 | var sink = function (dragApi, settings) { |
||
| 4626 | var blocker = Blocker(settings); |
||
| 637 | daniel-mar | 4627 | var mdown = bind(blocker.element(), 'mousedown', dragApi.forceDrop); |
| 4628 | var mup = bind(blocker.element(), 'mouseup', dragApi.drop); |
||
| 4629 | var mmove = bind(blocker.element(), 'mousemove', dragApi.move); |
||
| 4630 | var mout = bind(blocker.element(), 'mouseout', dragApi.delayDrop); |
||
| 597 | daniel-mar | 4631 | var destroy = function () { |
| 4632 | blocker.destroy(); |
||
| 4633 | mup.unbind(); |
||
| 4634 | mmove.unbind(); |
||
| 4635 | mout.unbind(); |
||
| 4636 | mdown.unbind(); |
||
| 4637 | }; |
||
| 4638 | var start = function (parent) { |
||
| 637 | daniel-mar | 4639 | append$1(parent, blocker.element()); |
| 597 | daniel-mar | 4640 | }; |
| 4641 | var stop = function () { |
||
| 637 | daniel-mar | 4642 | remove$5(blocker.element()); |
| 597 | daniel-mar | 4643 | }; |
| 4644 | return DragSink({ |
||
| 4645 | element: blocker.element, |
||
| 4646 | start: start, |
||
| 4647 | stop: stop, |
||
| 4648 | destroy: destroy |
||
| 4649 | }); |
||
| 4650 | }; |
||
| 4651 | var MouseDrag = DragMode({ |
||
| 4652 | compare: compare, |
||
| 637 | daniel-mar | 4653 | extract: extract, |
| 597 | daniel-mar | 4654 | sink: sink, |
| 4655 | mutate: mutate |
||
| 4656 | }); |
||
| 4657 | |||
| 637 | daniel-mar | 4658 | var transform$1 = function (mutation, settings) { |
| 597 | daniel-mar | 4659 | if (settings === void 0) { |
| 4660 | settings = {}; |
||
| 4661 | } |
||
| 4662 | var mode = settings.mode !== undefined ? settings.mode : MouseDrag; |
||
| 4663 | return setup(mutation, mode, settings); |
||
| 4664 | }; |
||
| 4665 | |||
| 637 | daniel-mar | 4666 | var closest = function (target) { |
| 4667 | return closest$1(target, '[contenteditable]'); |
||
| 597 | daniel-mar | 4668 | }; |
| 637 | daniel-mar | 4669 | var isEditable$1 = function (element, assumeEditable) { |
| 4670 | if (assumeEditable === void 0) { |
||
| 4671 | assumeEditable = false; |
||
| 4672 | } |
||
| 4673 | if (!detect$3().browser.isIE() && inBody(element)) { |
||
| 4674 | return element.dom.isContentEditable; |
||
| 4675 | } else { |
||
| 4676 | return closest(element).fold(constant(assumeEditable), function (editable) { |
||
| 4677 | return getRaw(editable) === 'true'; |
||
| 4678 | }); |
||
| 4679 | } |
||
| 597 | daniel-mar | 4680 | }; |
| 637 | daniel-mar | 4681 | var getRaw = function (element) { |
| 4682 | return element.dom.contentEditable; |
||
| 4683 | }; |
||
| 597 | daniel-mar | 4684 | |
| 637 | daniel-mar | 4685 | var styles = css('ephox-snooker'); |
| 4686 | var resolve = styles.resolve; |
||
| 597 | daniel-mar | 4687 | |
| 4688 | var Mutation = function () { |
||
| 637 | daniel-mar | 4689 | var events = create$4({ |
| 597 | daniel-mar | 4690 | drag: Event([ |
| 4691 | 'xDelta', |
||
| 4692 | 'yDelta' |
||
| 4693 | ]) |
||
| 4694 | }); |
||
| 4695 | var mutate = function (x, y) { |
||
| 4696 | events.trigger.drag(x, y); |
||
| 4697 | }; |
||
| 4698 | return { |
||
| 4699 | mutate: mutate, |
||
| 4700 | events: events.registry |
||
| 4701 | }; |
||
| 4702 | }; |
||
| 4703 | |||
| 4704 | var BarMutation = function () { |
||
| 637 | daniel-mar | 4705 | var events = create$4({ |
| 597 | daniel-mar | 4706 | drag: Event([ |
| 4707 | 'xDelta', |
||
| 4708 | 'yDelta', |
||
| 4709 | 'target' |
||
| 4710 | ]) |
||
| 4711 | }); |
||
| 4712 | var target = Optional.none(); |
||
| 4713 | var delegate = Mutation(); |
||
| 4714 | delegate.events.drag.bind(function (event) { |
||
| 4715 | target.each(function (t) { |
||
| 4716 | events.trigger.drag(event.xDelta, event.yDelta, t); |
||
| 4717 | }); |
||
| 4718 | }); |
||
| 4719 | var assign = function (t) { |
||
| 4720 | target = Optional.some(t); |
||
| 4721 | }; |
||
| 4722 | var get = function () { |
||
| 4723 | return target; |
||
| 4724 | }; |
||
| 4725 | return { |
||
| 4726 | assign: assign, |
||
| 4727 | get: get, |
||
| 4728 | mutate: delegate.mutate, |
||
| 4729 | events: events.registry |
||
| 4730 | }; |
||
| 4731 | }; |
||
| 4732 | |||
| 4733 | var col = function (column, x, y, w, h) { |
||
| 4734 | var bar = SugarElement.fromTag('div'); |
||
| 637 | daniel-mar | 4735 | setAll(bar, { |
| 597 | daniel-mar | 4736 | position: 'absolute', |
| 4737 | left: x - w / 2 + 'px', |
||
| 4738 | top: y + 'px', |
||
| 4739 | height: h + 'px', |
||
| 4740 | width: w + 'px' |
||
| 4741 | }); |
||
| 637 | daniel-mar | 4742 | setAll$1(bar, { |
| 597 | daniel-mar | 4743 | 'data-column': column, |
| 4744 | 'role': 'presentation' |
||
| 4745 | }); |
||
| 4746 | return bar; |
||
| 4747 | }; |
||
| 4748 | var row = function (r, x, y, w, h) { |
||
| 4749 | var bar = SugarElement.fromTag('div'); |
||
| 637 | daniel-mar | 4750 | setAll(bar, { |
| 597 | daniel-mar | 4751 | position: 'absolute', |
| 4752 | left: x + 'px', |
||
| 4753 | top: y - h / 2 + 'px', |
||
| 4754 | height: h + 'px', |
||
| 4755 | width: w + 'px' |
||
| 4756 | }); |
||
| 637 | daniel-mar | 4757 | setAll$1(bar, { |
| 597 | daniel-mar | 4758 | 'data-row': r, |
| 4759 | 'role': 'presentation' |
||
| 4760 | }); |
||
| 4761 | return bar; |
||
| 4762 | }; |
||
| 4763 | |||
| 637 | daniel-mar | 4764 | var resizeBar = resolve('resizer-bar'); |
| 4765 | var resizeRowBar = resolve('resizer-rows'); |
||
| 4766 | var resizeColBar = resolve('resizer-cols'); |
||
| 597 | daniel-mar | 4767 | var BAR_THICKNESS = 7; |
| 4768 | var resizableRows = function (warehouse, isResizable) { |
||
| 637 | daniel-mar | 4769 | return bind$2(warehouse.all, function (row, i) { |
| 597 | daniel-mar | 4770 | return isResizable(row.element) ? [i] : []; |
| 4771 | }); |
||
| 4772 | }; |
||
| 4773 | var resizableColumns = function (warehouse, isResizable) { |
||
| 4774 | var resizableCols = []; |
||
| 637 | daniel-mar | 4775 | range$1(warehouse.grid.columns, function (index) { |
| 597 | daniel-mar | 4776 | var colElmOpt = Warehouse.getColumnAt(warehouse, index).map(function (col) { |
| 4777 | return col.element; |
||
| 4778 | }); |
||
| 4779 | if (colElmOpt.forall(isResizable)) { |
||
| 4780 | resizableCols.push(index); |
||
| 4781 | } |
||
| 4782 | }); |
||
| 637 | daniel-mar | 4783 | return filter$2(resizableCols, function (colIndex) { |
| 597 | daniel-mar | 4784 | var columnCells = Warehouse.filterItems(warehouse, function (cell) { |
| 4785 | return cell.column === colIndex; |
||
| 4786 | }); |
||
| 4787 | return forall(columnCells, function (cell) { |
||
| 4788 | return isResizable(cell.element); |
||
| 4789 | }); |
||
| 4790 | }); |
||
| 4791 | }; |
||
| 4792 | var destroy = function (wire) { |
||
| 637 | daniel-mar | 4793 | var previous = descendants(wire.parent(), '.' + resizeBar); |
| 4794 | each$2(previous, remove$5); |
||
| 597 | daniel-mar | 4795 | }; |
| 4796 | var drawBar = function (wire, positions, create) { |
||
| 4797 | var origin = wire.origin(); |
||
| 637 | daniel-mar | 4798 | each$2(positions, function (cpOption) { |
| 597 | daniel-mar | 4799 | cpOption.each(function (cp) { |
| 4800 | var bar = create(origin, cp); |
||
| 637 | daniel-mar | 4801 | add(bar, resizeBar); |
| 4802 | append$1(wire.parent(), bar); |
||
| 597 | daniel-mar | 4803 | }); |
| 4804 | }); |
||
| 4805 | }; |
||
| 4806 | var refreshCol = function (wire, colPositions, position, tableHeight) { |
||
| 4807 | drawBar(wire, colPositions, function (origin, cp) { |
||
| 4808 | var colBar = col(cp.col, cp.x - origin.left, position.top - origin.top, BAR_THICKNESS, tableHeight); |
||
| 637 | daniel-mar | 4809 | add(colBar, resizeColBar); |
| 597 | daniel-mar | 4810 | return colBar; |
| 4811 | }); |
||
| 4812 | }; |
||
| 4813 | var refreshRow = function (wire, rowPositions, position, tableWidth) { |
||
| 4814 | drawBar(wire, rowPositions, function (origin, cp) { |
||
| 4815 | var rowBar = row(cp.row, position.left - origin.left, cp.y - origin.top, tableWidth, BAR_THICKNESS); |
||
| 637 | daniel-mar | 4816 | add(rowBar, resizeRowBar); |
| 597 | daniel-mar | 4817 | return rowBar; |
| 4818 | }); |
||
| 4819 | }; |
||
| 4820 | var refreshGrid = function (warhouse, wire, table, rows, cols) { |
||
| 4821 | var position = absolute(table); |
||
| 4822 | var isResizable = wire.isResizable; |
||
| 4823 | var rowPositions = rows.length > 0 ? height.positions(rows, table) : []; |
||
| 4824 | var resizableRowBars = rowPositions.length > 0 ? resizableRows(warhouse, isResizable) : []; |
||
| 637 | daniel-mar | 4825 | var resizableRowPositions = filter$2(rowPositions, function (_pos, i) { |
| 597 | daniel-mar | 4826 | return exists(resizableRowBars, function (barIndex) { |
| 4827 | return i === barIndex; |
||
| 4828 | }); |
||
| 4829 | }); |
||
| 637 | daniel-mar | 4830 | refreshRow(wire, resizableRowPositions, position, getOuter$2(table)); |
| 597 | daniel-mar | 4831 | var colPositions = cols.length > 0 ? width.positions(cols, table) : []; |
| 4832 | var resizableColBars = colPositions.length > 0 ? resizableColumns(warhouse, isResizable) : []; |
||
| 637 | daniel-mar | 4833 | var resizableColPositions = filter$2(colPositions, function (_pos, i) { |
| 597 | daniel-mar | 4834 | return exists(resizableColBars, function (barIndex) { |
| 4835 | return i === barIndex; |
||
| 4836 | }); |
||
| 4837 | }); |
||
| 4838 | refreshCol(wire, resizableColPositions, position, getOuter$1(table)); |
||
| 4839 | }; |
||
| 4840 | var refresh = function (wire, table) { |
||
| 4841 | destroy(wire); |
||
| 4842 | if (wire.isResizable(table)) { |
||
| 4843 | var warehouse = Warehouse.fromTable(table); |
||
| 637 | daniel-mar | 4844 | var rows$1 = rows(warehouse); |
| 4845 | var cols = columns(warehouse); |
||
| 4846 | refreshGrid(warehouse, wire, table, rows$1, cols); |
||
| 597 | daniel-mar | 4847 | } |
| 4848 | }; |
||
| 637 | daniel-mar | 4849 | var each = function (wire, f) { |
| 4850 | var bars = descendants(wire.parent(), '.' + resizeBar); |
||
| 4851 | each$2(bars, f); |
||
| 597 | daniel-mar | 4852 | }; |
| 4853 | var hide = function (wire) { |
||
| 637 | daniel-mar | 4854 | each(wire, function (bar) { |
| 597 | daniel-mar | 4855 | set$1(bar, 'display', 'none'); |
| 4856 | }); |
||
| 4857 | }; |
||
| 4858 | var show = function (wire) { |
||
| 637 | daniel-mar | 4859 | each(wire, function (bar) { |
| 597 | daniel-mar | 4860 | set$1(bar, 'display', 'block'); |
| 4861 | }); |
||
| 4862 | }; |
||
| 4863 | var isRowBar = function (element) { |
||
| 637 | daniel-mar | 4864 | return has(element, resizeRowBar); |
| 597 | daniel-mar | 4865 | }; |
| 4866 | var isColBar = function (element) { |
||
| 637 | daniel-mar | 4867 | return has(element, resizeColBar); |
| 597 | daniel-mar | 4868 | }; |
| 4869 | |||
| 637 | daniel-mar | 4870 | var resizeBarDragging = resolve('resizer-bar-dragging'); |
| 597 | daniel-mar | 4871 | var BarManager = function (wire) { |
| 4872 | var mutation = BarMutation(); |
||
| 637 | daniel-mar | 4873 | var resizing = transform$1(mutation, {}); |
| 597 | daniel-mar | 4874 | var hoverTable = Optional.none(); |
| 4875 | var getResizer = function (element, type) { |
||
| 637 | daniel-mar | 4876 | return Optional.from(get$b(element, type)); |
| 597 | daniel-mar | 4877 | }; |
| 4878 | mutation.events.drag.bind(function (event) { |
||
| 4879 | getResizer(event.target, 'data-row').each(function (_dataRow) { |
||
| 4880 | var currentRow = getCssValue(event.target, 'top'); |
||
| 4881 | set$1(event.target, 'top', currentRow + event.yDelta + 'px'); |
||
| 4882 | }); |
||
| 4883 | getResizer(event.target, 'data-column').each(function (_dataCol) { |
||
| 4884 | var currentCol = getCssValue(event.target, 'left'); |
||
| 4885 | set$1(event.target, 'left', currentCol + event.xDelta + 'px'); |
||
| 4886 | }); |
||
| 4887 | }); |
||
| 4888 | var getDelta = function (target, dir) { |
||
| 4889 | var newX = getCssValue(target, dir); |
||
| 4890 | var oldX = getAttrValue(target, 'data-initial-' + dir, 0); |
||
| 4891 | return newX - oldX; |
||
| 4892 | }; |
||
| 4893 | resizing.events.stop.bind(function () { |
||
| 4894 | mutation.get().each(function (target) { |
||
| 4895 | hoverTable.each(function (table) { |
||
| 4896 | getResizer(target, 'data-row').each(function (row) { |
||
| 4897 | var delta = getDelta(target, 'top'); |
||
| 637 | daniel-mar | 4898 | remove$7(target, 'data-initial-top'); |
| 597 | daniel-mar | 4899 | events.trigger.adjustHeight(table, delta, parseInt(row, 10)); |
| 4900 | }); |
||
| 4901 | getResizer(target, 'data-column').each(function (column) { |
||
| 4902 | var delta = getDelta(target, 'left'); |
||
| 637 | daniel-mar | 4903 | remove$7(target, 'data-initial-left'); |
| 597 | daniel-mar | 4904 | events.trigger.adjustWidth(table, delta, parseInt(column, 10)); |
| 4905 | }); |
||
| 4906 | refresh(wire, table); |
||
| 4907 | }); |
||
| 4908 | }); |
||
| 4909 | }); |
||
| 4910 | var handler = function (target, dir) { |
||
| 4911 | events.trigger.startAdjust(); |
||
| 4912 | mutation.assign(target); |
||
| 637 | daniel-mar | 4913 | set$2(target, 'data-initial-' + dir, getCssValue(target, dir)); |
| 4914 | add(target, resizeBarDragging); |
||
| 597 | daniel-mar | 4915 | set$1(target, 'opacity', '0.2'); |
| 4916 | resizing.go(wire.parent()); |
||
| 4917 | }; |
||
| 637 | daniel-mar | 4918 | var mousedown = bind(wire.parent(), 'mousedown', function (event) { |
| 597 | daniel-mar | 4919 | if (isRowBar(event.target)) { |
| 4920 | handler(event.target, 'top'); |
||
| 4921 | } |
||
| 4922 | if (isColBar(event.target)) { |
||
| 4923 | handler(event.target, 'left'); |
||
| 4924 | } |
||
| 4925 | }); |
||
| 4926 | var isRoot = function (e) { |
||
| 4927 | return eq$1(e, wire.view()); |
||
| 4928 | }; |
||
| 4929 | var findClosestEditableTable = function (target) { |
||
| 637 | daniel-mar | 4930 | return closest$1(target, 'table', isRoot).filter(isEditable$1); |
| 597 | daniel-mar | 4931 | }; |
| 637 | daniel-mar | 4932 | var mouseover = bind(wire.view(), 'mouseover', function (event) { |
| 597 | daniel-mar | 4933 | findClosestEditableTable(event.target).fold(function () { |
| 4934 | if (inBody(event.target)) { |
||
| 4935 | destroy(wire); |
||
| 4936 | } |
||
| 4937 | }, function (table) { |
||
| 4938 | hoverTable = Optional.some(table); |
||
| 4939 | refresh(wire, table); |
||
| 4940 | }); |
||
| 4941 | }); |
||
| 4942 | var destroy$1 = function () { |
||
| 4943 | mousedown.unbind(); |
||
| 4944 | mouseover.unbind(); |
||
| 4945 | resizing.destroy(); |
||
| 4946 | destroy(wire); |
||
| 4947 | }; |
||
| 4948 | var refresh$1 = function (tbl) { |
||
| 4949 | refresh(wire, tbl); |
||
| 4950 | }; |
||
| 637 | daniel-mar | 4951 | var events = create$4({ |
| 597 | daniel-mar | 4952 | adjustHeight: Event([ |
| 4953 | 'table', |
||
| 4954 | 'delta', |
||
| 4955 | 'row' |
||
| 4956 | ]), |
||
| 4957 | adjustWidth: Event([ |
||
| 4958 | 'table', |
||
| 4959 | 'delta', |
||
| 4960 | 'column' |
||
| 4961 | ]), |
||
| 4962 | startAdjust: Event([]) |
||
| 4963 | }); |
||
| 4964 | return { |
||
| 4965 | destroy: destroy$1, |
||
| 4966 | refresh: refresh$1, |
||
| 4967 | on: resizing.on, |
||
| 4968 | off: resizing.off, |
||
| 4969 | hideBars: curry(hide, wire), |
||
| 4970 | showBars: curry(show, wire), |
||
| 4971 | events: events.registry |
||
| 4972 | }; |
||
| 4973 | }; |
||
| 4974 | |||
| 637 | daniel-mar | 4975 | var create$3 = function (wire, resizing, lazySizing) { |
| 597 | daniel-mar | 4976 | var hdirection = height; |
| 4977 | var vdirection = width; |
||
| 4978 | var manager = BarManager(wire); |
||
| 637 | daniel-mar | 4979 | var events = create$4({ |
| 597 | daniel-mar | 4980 | beforeResize: Event([ |
| 4981 | 'table', |
||
| 4982 | 'type' |
||
| 4983 | ]), |
||
| 4984 | afterResize: Event([ |
||
| 4985 | 'table', |
||
| 4986 | 'type' |
||
| 4987 | ]), |
||
| 4988 | startDrag: Event([]) |
||
| 4989 | }); |
||
| 4990 | manager.events.adjustHeight.bind(function (event) { |
||
| 4991 | var table = event.table; |
||
| 4992 | events.trigger.beforeResize(table, 'row'); |
||
| 4993 | var delta = hdirection.delta(event.delta, table); |
||
| 4994 | adjustHeight(table, delta, event.row, hdirection); |
||
| 4995 | events.trigger.afterResize(table, 'row'); |
||
| 4996 | }); |
||
| 4997 | manager.events.startAdjust.bind(function (_event) { |
||
| 4998 | events.trigger.startDrag(); |
||
| 4999 | }); |
||
| 5000 | manager.events.adjustWidth.bind(function (event) { |
||
| 5001 | var table = event.table; |
||
| 5002 | events.trigger.beforeResize(table, 'col'); |
||
| 5003 | var delta = vdirection.delta(event.delta, table); |
||
| 5004 | var tableSize = lazySizing(table); |
||
| 5005 | adjustWidth(table, delta, event.column, resizing, tableSize); |
||
| 5006 | events.trigger.afterResize(table, 'col'); |
||
| 5007 | }); |
||
| 5008 | return { |
||
| 5009 | on: manager.on, |
||
| 5010 | off: manager.off, |
||
| 5011 | hideBars: manager.hideBars, |
||
| 5012 | showBars: manager.showBars, |
||
| 5013 | destroy: manager.destroy, |
||
| 5014 | events: events.registry |
||
| 5015 | }; |
||
| 5016 | }; |
||
| 637 | daniel-mar | 5017 | var TableResize = { create: create$3 }; |
| 597 | daniel-mar | 5018 | |
| 5019 | var fireNewRow = function (editor, row) { |
||
| 5020 | return editor.fire('newrow', { node: row }); |
||
| 5021 | }; |
||
| 5022 | var fireNewCell = function (editor, cell) { |
||
| 5023 | return editor.fire('newcell', { node: cell }); |
||
| 5024 | }; |
||
| 5025 | var fireObjectResizeStart = function (editor, target, width, height, origin) { |
||
| 5026 | editor.fire('ObjectResizeStart', { |
||
| 5027 | target: target, |
||
| 5028 | width: width, |
||
| 5029 | height: height, |
||
| 5030 | origin: origin |
||
| 5031 | }); |
||
| 5032 | }; |
||
| 5033 | var fireObjectResized = function (editor, target, width, height, origin) { |
||
| 5034 | editor.fire('ObjectResized', { |
||
| 5035 | target: target, |
||
| 5036 | width: width, |
||
| 5037 | height: height, |
||
| 5038 | origin: origin |
||
| 5039 | }); |
||
| 5040 | }; |
||
| 5041 | var fireTableSelectionChange = function (editor, cells, start, finish, otherCells) { |
||
| 5042 | editor.fire('TableSelectionChange', { |
||
| 5043 | cells: cells, |
||
| 5044 | start: start, |
||
| 5045 | finish: finish, |
||
| 5046 | otherCells: otherCells |
||
| 5047 | }); |
||
| 5048 | }; |
||
| 5049 | var fireTableSelectionClear = function (editor) { |
||
| 5050 | editor.fire('TableSelectionClear'); |
||
| 5051 | }; |
||
| 5052 | var fireTableModified = function (editor, table, data) { |
||
| 5053 | editor.fire('TableModified', __assign(__assign({}, data), { table: table })); |
||
| 5054 | }; |
||
| 5055 | var styleModified = { |
||
| 5056 | structure: false, |
||
| 5057 | style: true |
||
| 5058 | }; |
||
| 5059 | var structureModified = { |
||
| 5060 | structure: true, |
||
| 5061 | style: false |
||
| 5062 | }; |
||
| 637 | daniel-mar | 5063 | var styleAndStructureModified = { |
| 5064 | structure: true, |
||
| 5065 | style: true |
||
| 5066 | }; |
||
| 597 | daniel-mar | 5067 | |
| 5068 | var defaultTableToolbar = 'tableprops tabledelete | tableinsertrowbefore tableinsertrowafter tabledeleterow | tableinsertcolbefore tableinsertcolafter tabledeletecol'; |
||
| 5069 | var defaultStyles = { |
||
| 5070 | 'border-collapse': 'collapse', |
||
| 5071 | 'width': '100%' |
||
| 5072 | }; |
||
| 637 | daniel-mar | 5073 | var defaultCellBorderWidths = range$1(5, function (i) { |
| 5074 | var size = i + 1 + 'px'; |
||
| 5075 | return { |
||
| 5076 | title: size, |
||
| 5077 | value: size |
||
| 5078 | }; |
||
| 5079 | }); |
||
| 5080 | var defaultCellBorderStyles = map$1([ |
||
| 5081 | 'Solid', |
||
| 5082 | 'Dotted', |
||
| 5083 | 'Dashed', |
||
| 5084 | 'Double', |
||
| 5085 | 'Groove', |
||
| 5086 | 'Ridge', |
||
| 5087 | 'Inset', |
||
| 5088 | 'Outset', |
||
| 5089 | 'None', |
||
| 5090 | 'Hidden' |
||
| 5091 | ], function (type) { |
||
| 5092 | return { |
||
| 5093 | title: type, |
||
| 5094 | value: type.toLowerCase() |
||
| 5095 | }; |
||
| 5096 | }); |
||
| 597 | daniel-mar | 5097 | var determineDefaultStyles = function (editor) { |
| 679 | daniel-mar | 5098 | var _a; |
| 597 | daniel-mar | 5099 | if (isPixelsForced(editor)) { |
| 679 | daniel-mar | 5100 | var dom = editor.dom; |
| 5101 | var parentBlock = (_a = dom.getParent(editor.selection.getStart(), dom.isBlock)) !== null && _a !== void 0 ? _a : editor.getBody(); |
||
| 5102 | var contentWidth = getInner(SugarElement.fromDom(parentBlock)); |
||
| 5103 | return __assign(__assign({}, defaultStyles), { width: contentWidth + 'px' }); |
||
| 597 | daniel-mar | 5104 | } else if (isResponsiveForced(editor)) { |
| 5105 | return filter$1(defaultStyles, function (_value, key) { |
||
| 5106 | return key !== 'width'; |
||
| 5107 | }); |
||
| 5108 | } else { |
||
| 5109 | return defaultStyles; |
||
| 5110 | } |
||
| 5111 | }; |
||
| 5112 | var defaultAttributes = { border: '1' }; |
||
| 5113 | var defaultColumnResizingBehaviour = 'preservetable'; |
||
| 5114 | var getTableSizingMode = function (editor) { |
||
| 5115 | return editor.getParam('table_sizing_mode', 'auto'); |
||
| 5116 | }; |
||
| 5117 | var getTableResponseWidth = function (editor) { |
||
| 5118 | return editor.getParam('table_responsive_width'); |
||
| 5119 | }; |
||
| 637 | daniel-mar | 5120 | var getTableBorderWidths = function (editor) { |
| 5121 | return editor.getParam('table_border_widths', defaultCellBorderWidths, 'array'); |
||
| 5122 | }; |
||
| 5123 | var getTableBorderStyles = function (editor) { |
||
| 5124 | return editor.getParam('table_border_styles', defaultCellBorderStyles, 'array'); |
||
| 5125 | }; |
||
| 597 | daniel-mar | 5126 | var getDefaultAttributes = function (editor) { |
| 5127 | return editor.getParam('table_default_attributes', defaultAttributes, 'object'); |
||
| 5128 | }; |
||
| 5129 | var getDefaultStyles = function (editor) { |
||
| 5130 | return editor.getParam('table_default_styles', determineDefaultStyles(editor), 'object'); |
||
| 5131 | }; |
||
| 5132 | var hasTableResizeBars = function (editor) { |
||
| 5133 | return editor.getParam('table_resize_bars', true, 'boolean'); |
||
| 5134 | }; |
||
| 5135 | var hasTabNavigation = function (editor) { |
||
| 5136 | return editor.getParam('table_tab_navigation', true, 'boolean'); |
||
| 5137 | }; |
||
| 5138 | var hasAdvancedCellTab = function (editor) { |
||
| 5139 | return editor.getParam('table_cell_advtab', true, 'boolean'); |
||
| 5140 | }; |
||
| 5141 | var hasAdvancedRowTab = function (editor) { |
||
| 5142 | return editor.getParam('table_row_advtab', true, 'boolean'); |
||
| 5143 | }; |
||
| 5144 | var hasAdvancedTableTab = function (editor) { |
||
| 5145 | return editor.getParam('table_advtab', true, 'boolean'); |
||
| 5146 | }; |
||
| 5147 | var hasAppearanceOptions = function (editor) { |
||
| 5148 | return editor.getParam('table_appearance_options', true, 'boolean'); |
||
| 5149 | }; |
||
| 5150 | var hasTableGrid = function (editor) { |
||
| 5151 | return editor.getParam('table_grid', true, 'boolean'); |
||
| 5152 | }; |
||
| 5153 | var shouldStyleWithCss = function (editor) { |
||
| 5154 | return editor.getParam('table_style_by_css', false, 'boolean'); |
||
| 5155 | }; |
||
| 5156 | var getCellClassList = function (editor) { |
||
| 5157 | return editor.getParam('table_cell_class_list', [], 'array'); |
||
| 5158 | }; |
||
| 5159 | var getRowClassList = function (editor) { |
||
| 5160 | return editor.getParam('table_row_class_list', [], 'array'); |
||
| 5161 | }; |
||
| 5162 | var getTableClassList = function (editor) { |
||
| 5163 | return editor.getParam('table_class_list', [], 'array'); |
||
| 5164 | }; |
||
| 5165 | var isPercentagesForced = function (editor) { |
||
| 5166 | return getTableSizingMode(editor) === 'relative' || getTableResponseWidth(editor) === true; |
||
| 5167 | }; |
||
| 5168 | var isPixelsForced = function (editor) { |
||
| 5169 | return getTableSizingMode(editor) === 'fixed' || getTableResponseWidth(editor) === false; |
||
| 5170 | }; |
||
| 5171 | var isResponsiveForced = function (editor) { |
||
| 5172 | return getTableSizingMode(editor) === 'responsive'; |
||
| 5173 | }; |
||
| 5174 | var getToolbar = function (editor) { |
||
| 5175 | return editor.getParam('table_toolbar', defaultTableToolbar); |
||
| 5176 | }; |
||
| 5177 | var useColumnGroup = function (editor) { |
||
| 5178 | return editor.getParam('table_use_colgroups', false, 'boolean'); |
||
| 5179 | }; |
||
| 5180 | var getTableHeaderType = function (editor) { |
||
| 5181 | var defaultValue = 'section'; |
||
| 5182 | var value = editor.getParam('table_header_type', defaultValue, 'string'); |
||
| 5183 | var validValues = [ |
||
| 5184 | 'section', |
||
| 5185 | 'cells', |
||
| 5186 | 'sectionCells', |
||
| 5187 | 'auto' |
||
| 5188 | ]; |
||
| 637 | daniel-mar | 5189 | if (!contains$2(validValues, value)) { |
| 597 | daniel-mar | 5190 | return defaultValue; |
| 5191 | } else { |
||
| 5192 | return value; |
||
| 5193 | } |
||
| 5194 | }; |
||
| 5195 | var getColumnResizingBehaviour = function (editor) { |
||
| 5196 | var validModes = [ |
||
| 5197 | 'preservetable', |
||
| 5198 | 'resizetable' |
||
| 5199 | ]; |
||
| 5200 | var givenMode = editor.getParam('table_column_resizing', defaultColumnResizingBehaviour, 'string'); |
||
| 637 | daniel-mar | 5201 | return find$1(validModes, function (mode) { |
| 597 | daniel-mar | 5202 | return mode === givenMode; |
| 5203 | }).getOr(defaultColumnResizingBehaviour); |
||
| 5204 | }; |
||
| 5205 | var isPreserveTableColumnResizing = function (editor) { |
||
| 5206 | return getColumnResizingBehaviour(editor) === 'preservetable'; |
||
| 5207 | }; |
||
| 5208 | var isResizeTableColumnResizing = function (editor) { |
||
| 5209 | return getColumnResizingBehaviour(editor) === 'resizetable'; |
||
| 5210 | }; |
||
| 5211 | var getCloneElements = function (editor) { |
||
| 5212 | var cloneElements = editor.getParam('table_clone_elements'); |
||
| 5213 | if (isString(cloneElements)) { |
||
| 5214 | return Optional.some(cloneElements.split(/[ ,]/)); |
||
| 5215 | } else if (Array.isArray(cloneElements)) { |
||
| 5216 | return Optional.some(cloneElements); |
||
| 5217 | } else { |
||
| 5218 | return Optional.none(); |
||
| 5219 | } |
||
| 5220 | }; |
||
| 5221 | var hasObjectResizing = function (editor) { |
||
| 5222 | var objectResizing = editor.getParam('object_resizing', true); |
||
| 5223 | return isString(objectResizing) ? objectResizing === 'table' : objectResizing; |
||
| 5224 | }; |
||
| 637 | daniel-mar | 5225 | var getTableBackgroundColorMap = function (editor) { |
| 5226 | return editor.getParam('table_background_color_map', [], 'array'); |
||
| 5227 | }; |
||
| 5228 | var getTableBorderColorMap = function (editor) { |
||
| 5229 | return editor.getParam('table_border_color_map', [], 'array'); |
||
| 5230 | }; |
||
| 597 | daniel-mar | 5231 | |
| 637 | daniel-mar | 5232 | var get$4 = function (editor, table) { |
| 597 | daniel-mar | 5233 | if (isPercentagesForced(editor)) { |
| 679 | daniel-mar | 5234 | return TableSize.percentageSize(table); |
| 597 | daniel-mar | 5235 | } else if (isPixelsForced(editor)) { |
| 679 | daniel-mar | 5236 | return TableSize.pixelSize(table); |
| 597 | daniel-mar | 5237 | } else { |
| 5238 | return TableSize.getTableSize(table); |
||
| 5239 | } |
||
| 5240 | }; |
||
| 5241 | |||
| 5242 | var cleanupLegacyAttributes = function (element) { |
||
| 637 | daniel-mar | 5243 | remove$7(element, 'width'); |
| 597 | daniel-mar | 5244 | }; |
| 679 | daniel-mar | 5245 | var convertToPercentSize = function (table) { |
| 5246 | var newWidth = getPercentTableWidth(table); |
||
| 5247 | redistribute(table, Optional.some(newWidth), Optional.none()); |
||
| 597 | daniel-mar | 5248 | cleanupLegacyAttributes(table); |
| 5249 | }; |
||
| 679 | daniel-mar | 5250 | var convertToPixelSize = function (table) { |
| 597 | daniel-mar | 5251 | var newWidth = getPixelTableWidth(table); |
| 679 | daniel-mar | 5252 | redistribute(table, Optional.some(newWidth), Optional.none()); |
| 597 | daniel-mar | 5253 | cleanupLegacyAttributes(table); |
| 5254 | }; |
||
| 5255 | var convertToNoneSize = function (table) { |
||
| 637 | daniel-mar | 5256 | remove$6(table, 'width'); |
| 5257 | var columns = columns$1(table); |
||
| 5258 | var rowElements = columns.length > 0 ? columns : cells$1(table); |
||
| 5259 | each$2(rowElements, function (cell) { |
||
| 5260 | remove$6(cell, 'width'); |
||
| 597 | daniel-mar | 5261 | cleanupLegacyAttributes(cell); |
| 5262 | }); |
||
| 5263 | cleanupLegacyAttributes(table); |
||
| 5264 | }; |
||
| 5265 | |||
| 679 | daniel-mar | 5266 | var enforcePercentage = convertToPercentSize; |
| 5267 | var enforcePixels = convertToPixelSize; |
||
| 597 | daniel-mar | 5268 | var enforceNone = convertToNoneSize; |
| 5269 | var syncPixels = function (table) { |
||
| 5270 | var warehouse = Warehouse.fromTable(table); |
||
| 5271 | if (!Warehouse.hasColumns(warehouse)) { |
||
| 637 | daniel-mar | 5272 | each$2(cells$1(table), function (cell) { |
| 5273 | var computedWidth = get$a(cell, 'width'); |
||
| 597 | daniel-mar | 5274 | set$1(cell, 'width', computedWidth); |
| 637 | daniel-mar | 5275 | remove$7(cell, 'width'); |
| 597 | daniel-mar | 5276 | }); |
| 5277 | } |
||
| 5278 | }; |
||
| 5279 | |||
| 5280 | var createContainer = function () { |
||
| 5281 | var container = SugarElement.fromTag('div'); |
||
| 637 | daniel-mar | 5282 | setAll(container, { |
| 597 | daniel-mar | 5283 | position: 'static', |
| 5284 | height: '0', |
||
| 5285 | width: '0', |
||
| 5286 | padding: '0', |
||
| 5287 | margin: '0', |
||
| 5288 | border: '0' |
||
| 5289 | }); |
||
| 637 | daniel-mar | 5290 | append$1(body$1(), container); |
| 597 | daniel-mar | 5291 | return container; |
| 5292 | }; |
||
| 637 | daniel-mar | 5293 | var get$3 = function (editor, isResizable) { |
| 5294 | return editor.inline ? ResizeWire.body(getBody(editor), createContainer(), isResizable) : ResizeWire.only(SugarElement.fromDom(editor.getDoc()), isResizable); |
||
| 597 | daniel-mar | 5295 | }; |
| 637 | daniel-mar | 5296 | var remove$1 = function (editor, wire) { |
| 597 | daniel-mar | 5297 | if (editor.inline) { |
| 637 | daniel-mar | 5298 | remove$5(wire.parent()); |
| 597 | daniel-mar | 5299 | } |
| 5300 | }; |
||
| 5301 | |||
| 5302 | var barResizerPrefix = 'bar-'; |
||
| 5303 | var isResizable = function (elm) { |
||
| 637 | daniel-mar | 5304 | return get$b(elm, 'data-mce-resize') !== 'false'; |
| 597 | daniel-mar | 5305 | }; |
| 5306 | var getResizeHandler = function (editor) { |
||
| 5307 | var selectionRng = Optional.none(); |
||
| 5308 | var resize = Optional.none(); |
||
| 5309 | var wire = Optional.none(); |
||
| 5310 | var startW; |
||
| 5311 | var startRawW; |
||
| 5312 | var isTable = function (elm) { |
||
| 5313 | return elm.nodeName === 'TABLE'; |
||
| 5314 | }; |
||
| 5315 | var lazyResize = function () { |
||
| 5316 | return resize; |
||
| 5317 | }; |
||
| 5318 | var lazyWire = function () { |
||
| 5319 | return wire.getOr(ResizeWire.only(SugarElement.fromDom(editor.getBody()), isResizable)); |
||
| 5320 | }; |
||
| 5321 | var lazySizing = function (table) { |
||
| 637 | daniel-mar | 5322 | return get$4(editor, table); |
| 597 | daniel-mar | 5323 | }; |
| 5324 | var lazyResizingBehaviour = function () { |
||
| 5325 | return isPreserveTableColumnResizing(editor) ? preserveTable() : resizeTable(); |
||
| 5326 | }; |
||
| 5327 | var getNumColumns = function (table) { |
||
| 5328 | return getGridSize(table).columns; |
||
| 5329 | }; |
||
| 5330 | var afterCornerResize = function (table, origin, width) { |
||
| 5331 | var isRightEdgeResize = endsWith(origin, 'e'); |
||
| 5332 | if (startRawW === '') { |
||
| 679 | daniel-mar | 5333 | enforcePercentage(table); |
| 597 | daniel-mar | 5334 | } |
| 5335 | if (width !== startW && startRawW !== '') { |
||
| 5336 | set$1(table, 'width', startRawW); |
||
| 5337 | var resizing = lazyResizingBehaviour(); |
||
| 5338 | var tableSize = lazySizing(table); |
||
| 5339 | var col = isPreserveTableColumnResizing(editor) || isRightEdgeResize ? getNumColumns(table) - 1 : 0; |
||
| 5340 | adjustWidth(table, width - startW, col, resizing, tableSize); |
||
| 637 | daniel-mar | 5341 | } else if (isPercentage$1(startRawW)) { |
| 597 | daniel-mar | 5342 | var percentW = parseFloat(startRawW.replace('%', '')); |
| 5343 | var targetPercentW = width * percentW / startW; |
||
| 5344 | set$1(table, 'width', targetPercentW + '%'); |
||
| 5345 | } |
||
| 5346 | if (isPixel(startRawW)) { |
||
| 5347 | syncPixels(table); |
||
| 5348 | } |
||
| 5349 | }; |
||
| 5350 | var destroy = function () { |
||
| 5351 | resize.each(function (sz) { |
||
| 5352 | sz.destroy(); |
||
| 5353 | }); |
||
| 5354 | wire.each(function (w) { |
||
| 637 | daniel-mar | 5355 | remove$1(editor, w); |
| 597 | daniel-mar | 5356 | }); |
| 5357 | }; |
||
| 5358 | editor.on('init', function () { |
||
| 637 | daniel-mar | 5359 | var rawWire = get$3(editor, isResizable); |
| 597 | daniel-mar | 5360 | wire = Optional.some(rawWire); |
| 5361 | if (hasObjectResizing(editor) && hasTableResizeBars(editor)) { |
||
| 5362 | var resizing = lazyResizingBehaviour(); |
||
| 5363 | var sz = TableResize.create(rawWire, resizing, lazySizing); |
||
| 5364 | sz.on(); |
||
| 5365 | sz.events.startDrag.bind(function (_event) { |
||
| 5366 | selectionRng = Optional.some(editor.selection.getRng()); |
||
| 5367 | }); |
||
| 5368 | sz.events.beforeResize.bind(function (event) { |
||
| 5369 | var rawTable = event.table.dom; |
||
| 637 | daniel-mar | 5370 | fireObjectResizeStart(editor, rawTable, getPixelWidth(rawTable), getPixelHeight(rawTable), barResizerPrefix + event.type); |
| 597 | daniel-mar | 5371 | }); |
| 5372 | sz.events.afterResize.bind(function (event) { |
||
| 5373 | var table = event.table; |
||
| 5374 | var rawTable = table.dom; |
||
| 5375 | removeDataStyle(table); |
||
| 5376 | selectionRng.each(function (rng) { |
||
| 5377 | editor.selection.setRng(rng); |
||
| 5378 | editor.focus(); |
||
| 5379 | }); |
||
| 637 | daniel-mar | 5380 | fireObjectResized(editor, rawTable, getPixelWidth(rawTable), getPixelHeight(rawTable), barResizerPrefix + event.type); |
| 597 | daniel-mar | 5381 | editor.undoManager.add(); |
| 5382 | }); |
||
| 5383 | resize = Optional.some(sz); |
||
| 5384 | } |
||
| 5385 | }); |
||
| 5386 | editor.on('ObjectResizeStart', function (e) { |
||
| 5387 | var targetElm = e.target; |
||
| 5388 | if (isTable(targetElm)) { |
||
| 5389 | var table = SugarElement.fromDom(targetElm); |
||
| 637 | daniel-mar | 5390 | each$2(editor.dom.select('.mce-clonedresizable'), function (clone) { |
| 597 | daniel-mar | 5391 | editor.dom.addClass(clone, 'mce-' + getColumnResizingBehaviour(editor) + '-columns'); |
| 5392 | }); |
||
| 637 | daniel-mar | 5393 | if (!isPixelSizing(table) && isPixelsForced(editor)) { |
| 679 | daniel-mar | 5394 | enforcePixels(table); |
| 637 | daniel-mar | 5395 | } else if (!isPercentSizing(table) && isPercentagesForced(editor)) { |
| 679 | daniel-mar | 5396 | enforcePercentage(table); |
| 597 | daniel-mar | 5397 | } |
| 637 | daniel-mar | 5398 | if (isNoneSizing(table) && startsWith(e.origin, barResizerPrefix)) { |
| 679 | daniel-mar | 5399 | enforcePercentage(table); |
| 597 | daniel-mar | 5400 | } |
| 5401 | startW = e.width; |
||
| 637 | daniel-mar | 5402 | startRawW = isResponsiveForced(editor) ? '' : getRawWidth(editor, targetElm).getOr(''); |
| 597 | daniel-mar | 5403 | } |
| 5404 | }); |
||
| 5405 | editor.on('ObjectResized', function (e) { |
||
| 5406 | var targetElm = e.target; |
||
| 5407 | if (isTable(targetElm)) { |
||
| 5408 | var table = SugarElement.fromDom(targetElm); |
||
| 5409 | var origin_1 = e.origin; |
||
| 5410 | if (startsWith(origin_1, 'corner-')) { |
||
| 5411 | afterCornerResize(table, origin_1, e.width); |
||
| 5412 | } |
||
| 5413 | removeDataStyle(table); |
||
| 5414 | fireTableModified(editor, table.dom, styleModified); |
||
| 5415 | } |
||
| 5416 | }); |
||
| 5417 | editor.on('SwitchMode', function () { |
||
| 5418 | lazyResize().each(function (resize) { |
||
| 5419 | if (editor.mode.isReadOnly()) { |
||
| 5420 | resize.hideBars(); |
||
| 5421 | } else { |
||
| 5422 | resize.showBars(); |
||
| 5423 | } |
||
| 5424 | }); |
||
| 5425 | }); |
||
| 5426 | return { |
||
| 5427 | lazyResize: lazyResize, |
||
| 5428 | lazyWire: lazyWire, |
||
| 5429 | destroy: destroy |
||
| 5430 | }; |
||
| 5431 | }; |
||
| 5432 | |||
| 5433 | var point = function (element, offset) { |
||
| 5434 | return { |
||
| 5435 | element: element, |
||
| 5436 | offset: offset |
||
| 5437 | }; |
||
| 5438 | }; |
||
| 5439 | |||
| 637 | daniel-mar | 5440 | var scan$1 = function (universe, element, direction) { |
| 597 | daniel-mar | 5441 | if (universe.property().isText(element) && universe.property().getText(element).trim().length === 0 || universe.property().isComment(element)) { |
| 5442 | return direction(element).bind(function (elem) { |
||
| 637 | daniel-mar | 5443 | return scan$1(universe, elem, direction).orThunk(function () { |
| 597 | daniel-mar | 5444 | return Optional.some(elem); |
| 5445 | }); |
||
| 5446 | }); |
||
| 5447 | } else { |
||
| 5448 | return Optional.none(); |
||
| 5449 | } |
||
| 5450 | }; |
||
| 5451 | var toEnd = function (universe, element) { |
||
| 5452 | if (universe.property().isText(element)) { |
||
| 5453 | return universe.property().getText(element).length; |
||
| 5454 | } |
||
| 5455 | var children = universe.property().children(element); |
||
| 5456 | return children.length; |
||
| 5457 | }; |
||
| 637 | daniel-mar | 5458 | var freefallRtl$2 = function (universe, element) { |
| 5459 | var candidate = scan$1(universe, element, universe.query().prevSibling).getOr(element); |
||
| 597 | daniel-mar | 5460 | if (universe.property().isText(candidate)) { |
| 5461 | return point(candidate, toEnd(universe, candidate)); |
||
| 5462 | } |
||
| 5463 | var children = universe.property().children(candidate); |
||
| 637 | daniel-mar | 5464 | return children.length > 0 ? freefallRtl$2(universe, children[children.length - 1]) : point(candidate, toEnd(universe, candidate)); |
| 597 | daniel-mar | 5465 | }; |
| 5466 | |||
| 637 | daniel-mar | 5467 | var freefallRtl$1 = freefallRtl$2; |
| 597 | daniel-mar | 5468 | |
| 637 | daniel-mar | 5469 | var universe$2 = DomUniverse(); |
| 5470 | var freefallRtl = function (element) { |
||
| 5471 | return freefallRtl$1(universe$2, element); |
||
| 597 | daniel-mar | 5472 | }; |
| 5473 | |||
| 5474 | var halve = function (main, other) { |
||
| 5475 | var colspan = getSpan(main, 'colspan'); |
||
| 5476 | if (colspan === 1) { |
||
| 5477 | var width = getGenericWidth(main); |
||
| 5478 | width.each(function (w) { |
||
| 5479 | var newWidth = w.value / 2; |
||
| 5480 | setGenericWidth(main, newWidth, w.unit); |
||
| 5481 | setGenericWidth(other, newWidth, w.unit); |
||
| 5482 | }); |
||
| 5483 | } |
||
| 5484 | }; |
||
| 5485 | |||
| 679 | daniel-mar | 5486 | var isHeaderCell = isTag('th'); |
| 5487 | var isHeaderCells = function (cells) { |
||
| 5488 | return forall(cells, function (cell) { |
||
| 5489 | return isHeaderCell(cell.element); |
||
| 5490 | }); |
||
| 5491 | }; |
||
| 637 | daniel-mar | 5492 | var getRowHeaderType = function (isHeaderRow, isHeaderCells) { |
| 5493 | if (isHeaderRow && isHeaderCells) { |
||
| 5494 | return 'sectionCells'; |
||
| 5495 | } else if (isHeaderRow) { |
||
| 5496 | return 'section'; |
||
| 5497 | } else { |
||
| 5498 | return 'cells'; |
||
| 5499 | } |
||
| 5500 | }; |
||
| 5501 | var getRowType$1 = function (row) { |
||
| 5502 | var isHeaderRow = row.section === 'thead'; |
||
| 5503 | var isHeaderCells = is(findCommonCellType(row.cells), 'th'); |
||
| 5504 | if (isHeaderRow || isHeaderCells) { |
||
| 5505 | return { |
||
| 5506 | type: 'header', |
||
| 5507 | subType: getRowHeaderType(isHeaderRow, isHeaderCells) |
||
| 5508 | }; |
||
| 5509 | } else if (row.section === 'tfoot') { |
||
| 5510 | return { type: 'footer' }; |
||
| 5511 | } else { |
||
| 5512 | return { type: 'body' }; |
||
| 5513 | } |
||
| 5514 | }; |
||
| 5515 | var findCommonCellType = function (cells) { |
||
| 5516 | var headerCells = filter$2(cells, function (cell) { |
||
| 679 | daniel-mar | 5517 | return isHeaderCell(cell.element); |
| 637 | daniel-mar | 5518 | }); |
| 5519 | if (headerCells.length === 0) { |
||
| 5520 | return Optional.some('td'); |
||
| 5521 | } else if (headerCells.length === cells.length) { |
||
| 5522 | return Optional.some('th'); |
||
| 5523 | } else { |
||
| 5524 | return Optional.none(); |
||
| 5525 | } |
||
| 5526 | }; |
||
| 5527 | var findCommonRowType = function (rows) { |
||
| 5528 | var rowTypes = map$1(rows, function (row) { |
||
| 5529 | return getRowType$1(row).type; |
||
| 5530 | }); |
||
| 5531 | var hasHeader = contains$2(rowTypes, 'header'); |
||
| 5532 | var hasFooter = contains$2(rowTypes, 'footer'); |
||
| 5533 | if (!hasHeader && !hasFooter) { |
||
| 5534 | return Optional.some('body'); |
||
| 5535 | } else { |
||
| 5536 | var hasBody = contains$2(rowTypes, 'body'); |
||
| 5537 | if (hasHeader && !hasBody && !hasFooter) { |
||
| 5538 | return Optional.some('header'); |
||
| 5539 | } else if (!hasHeader && !hasBody && hasFooter) { |
||
| 5540 | return Optional.some('footer'); |
||
| 5541 | } else { |
||
| 5542 | return Optional.none(); |
||
| 5543 | } |
||
| 5544 | } |
||
| 5545 | }; |
||
| 5546 | var findTableRowHeaderType = function (warehouse) { |
||
| 5547 | return findMap(warehouse.all, function (row) { |
||
| 5548 | var rowType = getRowType$1(row); |
||
| 5549 | return rowType.type === 'header' ? Optional.from(rowType.subType) : Optional.none(); |
||
| 5550 | }); |
||
| 5551 | }; |
||
| 5552 | |||
| 5553 | var transformCell = function (cell, comparator, substitution) { |
||
| 5554 | return elementnew(substitution(cell.element, comparator), true, cell.isLocked); |
||
| 5555 | }; |
||
| 5556 | var transformRow = function (row, section) { |
||
| 5557 | return row.section !== section ? rowcells(row.element, row.cells, section, row.isNew) : row; |
||
| 5558 | }; |
||
| 5559 | var section = function () { |
||
| 5560 | return { |
||
| 5561 | transformRow: transformRow, |
||
| 5562 | transformCell: function (cell, comparator, substitution) { |
||
| 5563 | var newCell = substitution(cell.element, comparator); |
||
| 5564 | var fixedCell = name(newCell) !== 'td' ? mutate$1(newCell, 'td') : newCell; |
||
| 5565 | return elementnew(fixedCell, cell.isNew, cell.isLocked); |
||
| 5566 | } |
||
| 5567 | }; |
||
| 5568 | }; |
||
| 5569 | var sectionCells = function () { |
||
| 5570 | return { |
||
| 5571 | transformRow: transformRow, |
||
| 5572 | transformCell: transformCell |
||
| 5573 | }; |
||
| 5574 | }; |
||
| 5575 | var cells = function () { |
||
| 5576 | return { |
||
| 5577 | transformRow: function (row, section) { |
||
| 5578 | var newSection = section === 'thead' ? 'tbody' : section; |
||
| 5579 | return transformRow(row, newSection); |
||
| 5580 | }, |
||
| 5581 | transformCell: transformCell |
||
| 5582 | }; |
||
| 5583 | }; |
||
| 5584 | var fallback = function () { |
||
| 5585 | return { |
||
| 5586 | transformRow: identity, |
||
| 5587 | transformCell: transformCell |
||
| 5588 | }; |
||
| 5589 | }; |
||
| 5590 | var getTableSectionType = function (table, fallback) { |
||
| 5591 | var warehouse = Warehouse.fromTable(table); |
||
| 5592 | var type = findTableRowHeaderType(warehouse).getOr(fallback); |
||
| 5593 | switch (type) { |
||
| 5594 | case 'section': |
||
| 5595 | return section(); |
||
| 5596 | case 'sectionCells': |
||
| 5597 | return sectionCells(); |
||
| 5598 | case 'cells': |
||
| 5599 | return cells(); |
||
| 5600 | } |
||
| 5601 | }; |
||
| 5602 | var TableSection = { |
||
| 5603 | getTableSectionType: getTableSectionType, |
||
| 5604 | section: section, |
||
| 5605 | sectionCells: sectionCells, |
||
| 5606 | cells: cells, |
||
| 5607 | fallback: fallback |
||
| 5608 | }; |
||
| 5609 | |||
| 597 | daniel-mar | 5610 | var setIfNot = function (element, property, value, ignore) { |
| 5611 | if (value === ignore) { |
||
| 637 | daniel-mar | 5612 | remove$7(element, property); |
| 597 | daniel-mar | 5613 | } else { |
| 637 | daniel-mar | 5614 | set$2(element, property, value); |
| 597 | daniel-mar | 5615 | } |
| 5616 | }; |
||
| 637 | daniel-mar | 5617 | var insert$1 = function (table, selector, element) { |
| 5618 | last$2(children$1(table, selector)).fold(function () { |
||
| 597 | daniel-mar | 5619 | return prepend(table, element); |
| 5620 | }, function (child) { |
||
| 637 | daniel-mar | 5621 | return after$5(child, element); |
| 597 | daniel-mar | 5622 | }); |
| 5623 | }; |
||
| 5624 | var generateSection = function (table, sectionName) { |
||
| 637 | daniel-mar | 5625 | var section = child$1(table, sectionName).getOrThunk(function () { |
| 597 | daniel-mar | 5626 | var newSection = SugarElement.fromTag(sectionName, owner(table).dom); |
| 5627 | if (sectionName === 'thead') { |
||
| 637 | daniel-mar | 5628 | insert$1(table, 'caption,colgroup', newSection); |
| 597 | daniel-mar | 5629 | } else if (sectionName === 'colgroup') { |
| 637 | daniel-mar | 5630 | insert$1(table, 'caption', newSection); |
| 597 | daniel-mar | 5631 | } else { |
| 637 | daniel-mar | 5632 | append$1(table, newSection); |
| 597 | daniel-mar | 5633 | } |
| 5634 | return newSection; |
||
| 5635 | }); |
||
| 5636 | empty(section); |
||
| 5637 | return section; |
||
| 5638 | }; |
||
| 637 | daniel-mar | 5639 | var render$1 = function (table, grid) { |
| 597 | daniel-mar | 5640 | var newRows = []; |
| 5641 | var newCells = []; |
||
| 5642 | var syncRows = function (gridSection) { |
||
| 637 | daniel-mar | 5643 | return map$1(gridSection, function (row) { |
| 597 | daniel-mar | 5644 | if (row.isNew) { |
| 5645 | newRows.push(row.element); |
||
| 5646 | } |
||
| 5647 | var tr = row.element; |
||
| 5648 | empty(tr); |
||
| 637 | daniel-mar | 5649 | each$2(row.cells, function (cell) { |
| 597 | daniel-mar | 5650 | if (cell.isNew) { |
| 5651 | newCells.push(cell.element); |
||
| 5652 | } |
||
| 5653 | setIfNot(cell.element, 'colspan', cell.colspan, 1); |
||
| 5654 | setIfNot(cell.element, 'rowspan', cell.rowspan, 1); |
||
| 637 | daniel-mar | 5655 | append$1(tr, cell.element); |
| 597 | daniel-mar | 5656 | }); |
| 5657 | return tr; |
||
| 5658 | }); |
||
| 5659 | }; |
||
| 5660 | var syncColGroup = function (gridSection) { |
||
| 637 | daniel-mar | 5661 | return bind$2(gridSection, function (colGroup) { |
| 5662 | return map$1(colGroup.cells, function (col) { |
||
| 597 | daniel-mar | 5663 | setIfNot(col.element, 'span', col.colspan, 1); |
| 5664 | return col.element; |
||
| 5665 | }); |
||
| 5666 | }); |
||
| 5667 | }; |
||
| 5668 | var renderSection = function (gridSection, sectionName) { |
||
| 5669 | var section = generateSection(table, sectionName); |
||
| 5670 | var sync = sectionName === 'colgroup' ? syncColGroup : syncRows; |
||
| 5671 | var sectionElems = sync(gridSection); |
||
| 637 | daniel-mar | 5672 | append(section, sectionElems); |
| 597 | daniel-mar | 5673 | }; |
| 5674 | var removeSection = function (sectionName) { |
||
| 637 | daniel-mar | 5675 | child$1(table, sectionName).each(remove$5); |
| 597 | daniel-mar | 5676 | }; |
| 5677 | var renderOrRemoveSection = function (gridSection, sectionName) { |
||
| 5678 | if (gridSection.length > 0) { |
||
| 5679 | renderSection(gridSection, sectionName); |
||
| 5680 | } else { |
||
| 5681 | removeSection(sectionName); |
||
| 5682 | } |
||
| 5683 | }; |
||
| 5684 | var headSection = []; |
||
| 5685 | var bodySection = []; |
||
| 5686 | var footSection = []; |
||
| 5687 | var columnGroupsSection = []; |
||
| 637 | daniel-mar | 5688 | each$2(grid, function (row) { |
| 597 | daniel-mar | 5689 | switch (row.section) { |
| 5690 | case 'thead': |
||
| 5691 | headSection.push(row); |
||
| 5692 | break; |
||
| 5693 | case 'tbody': |
||
| 5694 | bodySection.push(row); |
||
| 5695 | break; |
||
| 5696 | case 'tfoot': |
||
| 5697 | footSection.push(row); |
||
| 5698 | break; |
||
| 5699 | case 'colgroup': |
||
| 5700 | columnGroupsSection.push(row); |
||
| 5701 | break; |
||
| 5702 | } |
||
| 5703 | }); |
||
| 5704 | renderOrRemoveSection(columnGroupsSection, 'colgroup'); |
||
| 5705 | renderOrRemoveSection(headSection, 'thead'); |
||
| 5706 | renderOrRemoveSection(bodySection, 'tbody'); |
||
| 5707 | renderOrRemoveSection(footSection, 'tfoot'); |
||
| 5708 | return { |
||
| 5709 | newRows: newRows, |
||
| 5710 | newCells: newCells |
||
| 5711 | }; |
||
| 5712 | }; |
||
| 637 | daniel-mar | 5713 | var copy = function (grid) { |
| 5714 | return map$1(grid, function (row) { |
||
| 597 | daniel-mar | 5715 | var tr = shallow(row.element); |
| 637 | daniel-mar | 5716 | each$2(row.cells, function (cell) { |
| 597 | daniel-mar | 5717 | var clonedCell = deep(cell.element); |
| 5718 | setIfNot(clonedCell, 'colspan', cell.colspan, 1); |
||
| 5719 | setIfNot(clonedCell, 'rowspan', cell.rowspan, 1); |
||
| 637 | daniel-mar | 5720 | append$1(tr, clonedCell); |
| 597 | daniel-mar | 5721 | }); |
| 5722 | return tr; |
||
| 5723 | }); |
||
| 5724 | }; |
||
| 5725 | |||
| 5726 | var getColumn = function (grid, index) { |
||
| 637 | daniel-mar | 5727 | return map$1(grid, function (row) { |
| 597 | daniel-mar | 5728 | return getCell(row, index); |
| 5729 | }); |
||
| 5730 | }; |
||
| 5731 | var getRow = function (grid, index) { |
||
| 5732 | return grid[index]; |
||
| 5733 | }; |
||
| 5734 | var findDiff = function (xs, comp) { |
||
| 5735 | if (xs.length === 0) { |
||
| 5736 | return 0; |
||
| 5737 | } |
||
| 5738 | var first = xs[0]; |
||
| 5739 | var index = findIndex(xs, function (x) { |
||
| 5740 | return !comp(first.element, x.element); |
||
| 5741 | }); |
||
| 637 | daniel-mar | 5742 | return index.getOr(xs.length); |
| 597 | daniel-mar | 5743 | }; |
| 5744 | var subgrid = function (grid, row, column, comparator) { |
||
| 679 | daniel-mar | 5745 | var gridRow = getRow(grid, row); |
| 5746 | var isColRow = gridRow.section === 'colgroup'; |
||
| 5747 | var colspan = findDiff(gridRow.cells.slice(column), comparator); |
||
| 5748 | var rowspan = isColRow ? 1 : findDiff(getColumn(grid.slice(row), column), comparator); |
||
| 597 | daniel-mar | 5749 | return { |
| 679 | daniel-mar | 5750 | colspan: colspan, |
| 5751 | rowspan: rowspan |
||
| 597 | daniel-mar | 5752 | }; |
| 5753 | }; |
||
| 5754 | |||
| 5755 | var toDetails = function (grid, comparator) { |
||
| 637 | daniel-mar | 5756 | var seen = map$1(grid, function (row) { |
| 5757 | return map$1(row.cells, never); |
||
| 597 | daniel-mar | 5758 | }); |
| 5759 | var updateSeen = function (rowIndex, columnIndex, rowspan, colspan) { |
||
| 5760 | for (var row = rowIndex; row < rowIndex + rowspan; row++) { |
||
| 5761 | for (var column = columnIndex; column < columnIndex + colspan; column++) { |
||
| 5762 | seen[row][column] = true; |
||
| 5763 | } |
||
| 5764 | } |
||
| 5765 | }; |
||
| 637 | daniel-mar | 5766 | return map$1(grid, function (row, rowIndex) { |
| 5767 | var details = bind$2(row.cells, function (cell, columnIndex) { |
||
| 597 | daniel-mar | 5768 | if (seen[rowIndex][columnIndex] === false) { |
| 5769 | var result = subgrid(grid, rowIndex, columnIndex, comparator); |
||
| 5770 | updateSeen(rowIndex, columnIndex, result.rowspan, result.colspan); |
||
| 5771 | return [detailnew(cell.element, result.rowspan, result.colspan, cell.isNew)]; |
||
| 5772 | } else { |
||
| 5773 | return []; |
||
| 5774 | } |
||
| 5775 | }); |
||
| 637 | daniel-mar | 5776 | return rowdetailnew(row.element, details, row.section, row.isNew); |
| 597 | daniel-mar | 5777 | }); |
| 5778 | }; |
||
| 5779 | var toGrid = function (warehouse, generators, isNew) { |
||
| 5780 | var grid = []; |
||
| 637 | daniel-mar | 5781 | each$2(warehouse.colgroups, function (colgroup) { |
| 679 | daniel-mar | 5782 | var colgroupCols = []; |
| 5783 | for (var columnIndex = 0; columnIndex < warehouse.grid.columns; columnIndex++) { |
||
| 5784 | var element = Warehouse.getColumnAt(warehouse, columnIndex).map(function (column) { |
||
| 5785 | return elementnew(column.element, isNew, false); |
||
| 5786 | }).getOrThunk(function () { |
||
| 5787 | return elementnew(generators.colGap(), true, false); |
||
| 5788 | }); |
||
| 5789 | colgroupCols.push(element); |
||
| 5790 | } |
||
| 5791 | grid.push(rowcells(colgroup.element, colgroupCols, 'colgroup', isNew)); |
||
| 637 | daniel-mar | 5792 | }); |
| 597 | daniel-mar | 5793 | for (var rowIndex = 0; rowIndex < warehouse.grid.rows; rowIndex++) { |
| 5794 | var rowCells = []; |
||
| 5795 | for (var columnIndex = 0; columnIndex < warehouse.grid.columns; columnIndex++) { |
||
| 5796 | var element = Warehouse.getAt(warehouse, rowIndex, columnIndex).map(function (item) { |
||
| 5797 | return elementnew(item.element, isNew, item.isLocked); |
||
| 5798 | }).getOrThunk(function () { |
||
| 5799 | return elementnew(generators.gap(), true, false); |
||
| 5800 | }); |
||
| 5801 | rowCells.push(element); |
||
| 5802 | } |
||
| 637 | daniel-mar | 5803 | var rowDetail = warehouse.all[rowIndex]; |
| 5804 | var row = rowcells(rowDetail.element, rowCells, rowDetail.section, isNew); |
||
| 597 | daniel-mar | 5805 | grid.push(row); |
| 5806 | } |
||
| 5807 | return grid; |
||
| 5808 | }; |
||
| 5809 | |||
| 5810 | var fromWarehouse = function (warehouse, generators) { |
||
| 5811 | return toGrid(warehouse, generators, false); |
||
| 5812 | }; |
||
| 637 | daniel-mar | 5813 | var toDetailList = function (grid) { |
| 5814 | return toDetails(grid, eq$1); |
||
| 597 | daniel-mar | 5815 | }; |
| 5816 | var findInWarehouse = function (warehouse, element) { |
||
| 5817 | return findMap(warehouse.all, function (r) { |
||
| 637 | daniel-mar | 5818 | return find$1(r.cells, function (e) { |
| 597 | daniel-mar | 5819 | return eq$1(element, e.element); |
| 5820 | }); |
||
| 5821 | }); |
||
| 5822 | }; |
||
| 5823 | var extractCells = function (warehouse, target, predicate) { |
||
| 637 | daniel-mar | 5824 | var details = map$1(target.selection, function (cell$1) { |
| 597 | daniel-mar | 5825 | return cell(cell$1).bind(function (lc) { |
| 5826 | return findInWarehouse(warehouse, lc); |
||
| 5827 | }).filter(predicate); |
||
| 5828 | }); |
||
| 5829 | var cells = cat(details); |
||
| 5830 | return someIf(cells.length > 0, cells); |
||
| 5831 | }; |
||
| 5832 | var run = function (operation, extract, adjustment, postAction, genWrappers) { |
||
| 637 | daniel-mar | 5833 | return function (wire, table, target, generators, behaviours) { |
| 597 | daniel-mar | 5834 | var warehouse = Warehouse.fromTable(table); |
| 637 | daniel-mar | 5835 | var tableSection = Optional.from(behaviours === null || behaviours === void 0 ? void 0 : behaviours.section).getOrThunk(TableSection.fallback); |
| 597 | daniel-mar | 5836 | var output = extract(warehouse, target).map(function (info) { |
| 5837 | var model = fromWarehouse(warehouse, generators); |
||
| 637 | daniel-mar | 5838 | var result = operation(model, info, eq$1, genWrappers(generators), tableSection); |
| 597 | daniel-mar | 5839 | var lockedColumns = getLockedColumnsFromGrid(result.grid); |
| 637 | daniel-mar | 5840 | var grid = toDetailList(result.grid); |
| 597 | daniel-mar | 5841 | return { |
| 5842 | info: info, |
||
| 5843 | grid: grid, |
||
| 5844 | cursor: result.cursor, |
||
| 5845 | lockedColumns: lockedColumns |
||
| 5846 | }; |
||
| 5847 | }); |
||
| 5848 | return output.bind(function (out) { |
||
| 637 | daniel-mar | 5849 | var newElements = render$1(table, out.grid); |
| 5850 | var tableSizing = Optional.from(behaviours === null || behaviours === void 0 ? void 0 : behaviours.sizing).getOrThunk(function () { |
||
| 597 | daniel-mar | 5851 | return TableSize.getTableSize(table); |
| 5852 | }); |
||
| 637 | daniel-mar | 5853 | var resizing = Optional.from(behaviours === null || behaviours === void 0 ? void 0 : behaviours.resize).getOrThunk(preserveTable); |
| 5854 | adjustment(table, out.grid, out.info, { |
||
| 5855 | sizing: tableSizing, |
||
| 5856 | resize: resizing, |
||
| 5857 | section: tableSection |
||
| 5858 | }); |
||
| 597 | daniel-mar | 5859 | postAction(table); |
| 5860 | refresh(wire, table); |
||
| 637 | daniel-mar | 5861 | remove$7(table, LOCKED_COL_ATTR); |
| 597 | daniel-mar | 5862 | if (out.lockedColumns.length > 0) { |
| 637 | daniel-mar | 5863 | set$2(table, LOCKED_COL_ATTR, out.lockedColumns.join(',')); |
| 597 | daniel-mar | 5864 | } |
| 5865 | return Optional.some({ |
||
| 5866 | cursor: out.cursor, |
||
| 5867 | newRows: newElements.newRows, |
||
| 5868 | newCells: newElements.newCells |
||
| 5869 | }); |
||
| 5870 | }); |
||
| 5871 | }; |
||
| 5872 | }; |
||
| 5873 | var onPaste = function (warehouse, target) { |
||
| 5874 | return cell(target.element).bind(function (cell) { |
||
| 5875 | return findInWarehouse(warehouse, cell).map(function (details) { |
||
| 5876 | var value = __assign(__assign({}, details), { |
||
| 5877 | generators: target.generators, |
||
| 5878 | clipboard: target.clipboard |
||
| 5879 | }); |
||
| 5880 | return value; |
||
| 5881 | }); |
||
| 5882 | }); |
||
| 5883 | }; |
||
| 5884 | var onPasteByEditor = function (warehouse, target) { |
||
| 5885 | return extractCells(warehouse, target, always).map(function (cells) { |
||
| 5886 | return { |
||
| 5887 | cells: cells, |
||
| 5888 | generators: target.generators, |
||
| 5889 | clipboard: target.clipboard |
||
| 5890 | }; |
||
| 5891 | }); |
||
| 5892 | }; |
||
| 5893 | var onMergable = function (_warehouse, target) { |
||
| 5894 | return target.mergable; |
||
| 5895 | }; |
||
| 5896 | var onUnmergable = function (_warehouse, target) { |
||
| 5897 | return target.unmergable; |
||
| 5898 | }; |
||
| 5899 | var onCells = function (warehouse, target) { |
||
| 5900 | return extractCells(warehouse, target, always); |
||
| 5901 | }; |
||
| 5902 | var onUnlockedCells = function (warehouse, target) { |
||
| 5903 | return extractCells(warehouse, target, function (detail) { |
||
| 5904 | return !detail.isLocked; |
||
| 5905 | }); |
||
| 5906 | }; |
||
| 5907 | var isUnlockedTableCell = function (warehouse, cell) { |
||
| 5908 | return findInWarehouse(warehouse, cell).exists(function (detail) { |
||
| 5909 | return !detail.isLocked; |
||
| 5910 | }); |
||
| 5911 | }; |
||
| 5912 | var allUnlocked = function (warehouse, cells) { |
||
| 5913 | return forall(cells, function (cell) { |
||
| 5914 | return isUnlockedTableCell(warehouse, cell); |
||
| 5915 | }); |
||
| 5916 | }; |
||
| 5917 | var onUnlockedMergable = function (warehouse, target) { |
||
| 5918 | return onMergable(warehouse, target).filter(function (mergeable) { |
||
| 5919 | return allUnlocked(warehouse, mergeable.cells); |
||
| 5920 | }); |
||
| 5921 | }; |
||
| 5922 | var onUnlockedUnmergable = function (warehouse, target) { |
||
| 5923 | return onUnmergable(warehouse, target).filter(function (cells) { |
||
| 5924 | return allUnlocked(warehouse, cells); |
||
| 5925 | }); |
||
| 5926 | }; |
||
| 5927 | |||
| 637 | daniel-mar | 5928 | var merge$2 = function (grid, bounds, comparator, substitution) { |
| 597 | daniel-mar | 5929 | var rows = extractGridDetails(grid).rows; |
| 5930 | if (rows.length === 0) { |
||
| 5931 | return grid; |
||
| 5932 | } |
||
| 5933 | for (var i = bounds.startRow; i <= bounds.finishRow; i++) { |
||
| 5934 | for (var j = bounds.startCol; j <= bounds.finishCol; j++) { |
||
| 5935 | var row = rows[i]; |
||
| 5936 | var isLocked = getCell(row, j).isLocked; |
||
| 5937 | mutateCell(row, j, elementnew(substitution(), false, isLocked)); |
||
| 5938 | } |
||
| 5939 | } |
||
| 5940 | return grid; |
||
| 5941 | }; |
||
| 5942 | var unmerge = function (grid, target, comparator, substitution) { |
||
| 5943 | var rows = extractGridDetails(grid).rows; |
||
| 5944 | var first = true; |
||
| 5945 | for (var i = 0; i < rows.length; i++) { |
||
| 5946 | for (var j = 0; j < cellLength(rows[0]); j++) { |
||
| 5947 | var row = rows[i]; |
||
| 5948 | var currentCell = getCell(row, j); |
||
| 5949 | var currentCellElm = currentCell.element; |
||
| 5950 | var isToReplace = comparator(currentCellElm, target); |
||
| 5951 | if (isToReplace === true && first === false) { |
||
| 5952 | mutateCell(row, j, elementnew(substitution(), true, currentCell.isLocked)); |
||
| 5953 | } else if (isToReplace === true) { |
||
| 5954 | first = false; |
||
| 5955 | } |
||
| 5956 | } |
||
| 5957 | } |
||
| 5958 | return grid; |
||
| 5959 | }; |
||
| 5960 | var uniqueCells = function (row, comparator) { |
||
| 5961 | return foldl(row, function (rest, cell) { |
||
| 5962 | return exists(rest, function (currentCell) { |
||
| 5963 | return comparator(currentCell.element, cell.element); |
||
| 5964 | }) ? rest : rest.concat([cell]); |
||
| 5965 | }, []); |
||
| 5966 | }; |
||
| 5967 | var splitCols = function (grid, index, comparator, substitution) { |
||
| 5968 | if (index > 0 && index < grid[0].cells.length) { |
||
| 637 | daniel-mar | 5969 | each$2(grid, function (row) { |
| 597 | daniel-mar | 5970 | var prevCell = row.cells[index - 1]; |
| 5971 | var current = row.cells[index]; |
||
| 5972 | var isToReplace = comparator(current.element, prevCell.element); |
||
| 5973 | if (isToReplace) { |
||
| 5974 | mutateCell(row, index, elementnew(substitution(), true, current.isLocked)); |
||
| 5975 | } |
||
| 5976 | }); |
||
| 5977 | } |
||
| 5978 | return grid; |
||
| 5979 | }; |
||
| 5980 | var splitRows = function (grid, index, comparator, substitution) { |
||
| 5981 | var rows = extractGridDetails(grid).rows; |
||
| 5982 | if (index > 0 && index < rows.length) { |
||
| 5983 | var rowPrevCells = rows[index - 1].cells; |
||
| 5984 | var cells = uniqueCells(rowPrevCells, comparator); |
||
| 637 | daniel-mar | 5985 | each$2(cells, function (cell) { |
| 597 | daniel-mar | 5986 | var replacement = Optional.none(); |
| 5987 | for (var i = index; i < rows.length; i++) { |
||
| 5988 | var _loop_1 = function (j) { |
||
| 5989 | var row = rows[i]; |
||
| 5990 | var current = getCell(row, j); |
||
| 5991 | var isToReplace = comparator(current.element, cell.element); |
||
| 5992 | if (isToReplace) { |
||
| 5993 | if (replacement.isNone()) { |
||
| 5994 | replacement = Optional.some(substitution()); |
||
| 5995 | } |
||
| 5996 | replacement.each(function (sub) { |
||
| 5997 | mutateCell(row, j, elementnew(sub, true, current.isLocked)); |
||
| 5998 | }); |
||
| 5999 | } |
||
| 6000 | }; |
||
| 6001 | for (var j = 0; j < cellLength(rows[0]); j++) { |
||
| 6002 | _loop_1(j); |
||
| 6003 | } |
||
| 6004 | } |
||
| 6005 | }); |
||
| 6006 | } |
||
| 6007 | return grid; |
||
| 6008 | }; |
||
| 6009 | |||
| 637 | daniel-mar | 6010 | var value$1 = function (o) { |
| 597 | daniel-mar | 6011 | var or = function (_opt) { |
| 637 | daniel-mar | 6012 | return value$1(o); |
| 597 | daniel-mar | 6013 | }; |
| 6014 | var orThunk = function (_f) { |
||
| 637 | daniel-mar | 6015 | return value$1(o); |
| 597 | daniel-mar | 6016 | }; |
| 6017 | var map = function (f) { |
||
| 637 | daniel-mar | 6018 | return value$1(f(o)); |
| 597 | daniel-mar | 6019 | }; |
| 6020 | var mapError = function (_f) { |
||
| 637 | daniel-mar | 6021 | return value$1(o); |
| 597 | daniel-mar | 6022 | }; |
| 6023 | var each = function (f) { |
||
| 6024 | f(o); |
||
| 6025 | }; |
||
| 6026 | var bind = function (f) { |
||
| 6027 | return f(o); |
||
| 6028 | }; |
||
| 6029 | var fold = function (_, onValue) { |
||
| 6030 | return onValue(o); |
||
| 6031 | }; |
||
| 6032 | var exists = function (f) { |
||
| 6033 | return f(o); |
||
| 6034 | }; |
||
| 6035 | var forall = function (f) { |
||
| 6036 | return f(o); |
||
| 6037 | }; |
||
| 6038 | var toOptional = function () { |
||
| 6039 | return Optional.some(o); |
||
| 6040 | }; |
||
| 6041 | return { |
||
| 6042 | isValue: always, |
||
| 6043 | isError: never, |
||
| 6044 | getOr: constant(o), |
||
| 6045 | getOrThunk: constant(o), |
||
| 6046 | getOrDie: constant(o), |
||
| 6047 | or: or, |
||
| 6048 | orThunk: orThunk, |
||
| 6049 | fold: fold, |
||
| 6050 | map: map, |
||
| 6051 | mapError: mapError, |
||
| 6052 | each: each, |
||
| 6053 | bind: bind, |
||
| 6054 | exists: exists, |
||
| 6055 | forall: forall, |
||
| 6056 | toOptional: toOptional |
||
| 6057 | }; |
||
| 6058 | }; |
||
| 6059 | var error = function (message) { |
||
| 6060 | var getOrThunk = function (f) { |
||
| 6061 | return f(); |
||
| 6062 | }; |
||
| 6063 | var getOrDie = function () { |
||
| 6064 | return die(String(message))(); |
||
| 6065 | }; |
||
| 637 | daniel-mar | 6066 | var or = identity; |
| 597 | daniel-mar | 6067 | var orThunk = function (f) { |
| 6068 | return f(); |
||
| 6069 | }; |
||
| 6070 | var map = function (_f) { |
||
| 6071 | return error(message); |
||
| 6072 | }; |
||
| 6073 | var mapError = function (f) { |
||
| 6074 | return error(f(message)); |
||
| 6075 | }; |
||
| 6076 | var bind = function (_f) { |
||
| 6077 | return error(message); |
||
| 6078 | }; |
||
| 6079 | var fold = function (onError, _) { |
||
| 6080 | return onError(message); |
||
| 6081 | }; |
||
| 6082 | return { |
||
| 6083 | isValue: never, |
||
| 6084 | isError: always, |
||
| 6085 | getOr: identity, |
||
| 6086 | getOrThunk: getOrThunk, |
||
| 6087 | getOrDie: getOrDie, |
||
| 6088 | or: or, |
||
| 6089 | orThunk: orThunk, |
||
| 6090 | fold: fold, |
||
| 6091 | map: map, |
||
| 6092 | mapError: mapError, |
||
| 6093 | each: noop, |
||
| 6094 | bind: bind, |
||
| 6095 | exists: never, |
||
| 6096 | forall: always, |
||
| 6097 | toOptional: Optional.none |
||
| 6098 | }; |
||
| 6099 | }; |
||
| 6100 | var fromOption = function (opt, err) { |
||
| 6101 | return opt.fold(function () { |
||
| 6102 | return error(err); |
||
| 637 | daniel-mar | 6103 | }, value$1); |
| 597 | daniel-mar | 6104 | }; |
| 6105 | var Result = { |
||
| 637 | daniel-mar | 6106 | value: value$1, |
| 597 | daniel-mar | 6107 | error: error, |
| 6108 | fromOption: fromOption |
||
| 6109 | }; |
||
| 6110 | |||
| 6111 | var measure = function (startAddress, gridA, gridB) { |
||
| 6112 | if (startAddress.row >= gridA.length || startAddress.column > cellLength(gridA[0])) { |
||
| 6113 | return Result.error('invalid start address out of table bounds, row: ' + startAddress.row + ', column: ' + startAddress.column); |
||
| 6114 | } |
||
| 6115 | var rowRemainder = gridA.slice(startAddress.row); |
||
| 6116 | var colRemainder = rowRemainder[0].cells.slice(startAddress.column); |
||
| 6117 | var colRequired = cellLength(gridB[0]); |
||
| 6118 | var rowRequired = gridB.length; |
||
| 6119 | return Result.value({ |
||
| 6120 | rowDelta: rowRemainder.length - rowRequired, |
||
| 6121 | colDelta: colRemainder.length - colRequired |
||
| 6122 | }); |
||
| 6123 | }; |
||
| 6124 | var measureWidth = function (gridA, gridB) { |
||
| 6125 | var colLengthA = cellLength(gridA[0]); |
||
| 6126 | var colLengthB = cellLength(gridB[0]); |
||
| 6127 | return { |
||
| 6128 | rowDelta: 0, |
||
| 6129 | colDelta: colLengthA - colLengthB |
||
| 6130 | }; |
||
| 6131 | }; |
||
| 6132 | var measureHeight = function (gridA, gridB) { |
||
| 6133 | var rowLengthA = gridA.length; |
||
| 6134 | var rowLengthB = gridB.length; |
||
| 6135 | return { |
||
| 6136 | rowDelta: rowLengthA - rowLengthB, |
||
| 6137 | colDelta: 0 |
||
| 6138 | }; |
||
| 6139 | }; |
||
| 6140 | var generateElements = function (amount, row, generators, isLocked) { |
||
| 6141 | var generator = row.section === 'colgroup' ? generators.col : generators.cell; |
||
| 637 | daniel-mar | 6142 | return range$1(amount, function (idx) { |
| 597 | daniel-mar | 6143 | return elementnew(generator(), true, isLocked(idx)); |
| 6144 | }); |
||
| 6145 | }; |
||
| 6146 | var rowFill = function (grid, amount, generators, lockedColumns) { |
||
| 637 | daniel-mar | 6147 | var exampleRow = grid[grid.length - 1]; |
| 6148 | return grid.concat(range$1(amount, function () { |
||
| 6149 | var generator = exampleRow.section === 'colgroup' ? generators.colgroup : generators.row; |
||
| 6150 | var row = clone$1(exampleRow, generator, identity); |
||
| 597 | daniel-mar | 6151 | var elements = generateElements(row.cells.length, row, generators, function (idx) { |
| 637 | daniel-mar | 6152 | return has$1(lockedColumns, idx.toString()); |
| 597 | daniel-mar | 6153 | }); |
| 6154 | return setCells(row, elements); |
||
| 6155 | })); |
||
| 6156 | }; |
||
| 6157 | var colFill = function (grid, amount, generators, startIndex) { |
||
| 637 | daniel-mar | 6158 | return map$1(grid, function (row) { |
| 597 | daniel-mar | 6159 | var newChildren = generateElements(amount, row, generators, never); |
| 6160 | return addCells(row, startIndex, newChildren); |
||
| 6161 | }); |
||
| 6162 | }; |
||
| 6163 | var lockedColFill = function (grid, generators, lockedColumns) { |
||
| 637 | daniel-mar | 6164 | return map$1(grid, function (row) { |
| 597 | daniel-mar | 6165 | return foldl(lockedColumns, function (acc, colNum) { |
| 6166 | var newChild = generateElements(1, row, generators, always)[0]; |
||
| 6167 | return addCell(acc, colNum, newChild); |
||
| 6168 | }, row); |
||
| 6169 | }); |
||
| 6170 | }; |
||
| 6171 | var tailor = function (gridA, delta, generators) { |
||
| 6172 | var fillCols = delta.colDelta < 0 ? colFill : identity; |
||
| 6173 | var fillRows = delta.rowDelta < 0 ? rowFill : identity; |
||
| 6174 | var lockedColumns = getLockedColumnsFromGrid(gridA); |
||
| 6175 | var gridWidth = cellLength(gridA[0]); |
||
| 6176 | var isLastColLocked = exists(lockedColumns, function (locked) { |
||
| 6177 | return locked === gridWidth - 1; |
||
| 6178 | }); |
||
| 6179 | var modifiedCols = fillCols(gridA, Math.abs(delta.colDelta), generators, isLastColLocked ? gridWidth - 1 : gridWidth); |
||
| 6180 | var newLockedColumns = getLockedColumnsFromGrid(modifiedCols); |
||
| 6181 | return fillRows(modifiedCols, Math.abs(delta.rowDelta), generators, mapToObject(newLockedColumns, always)); |
||
| 6182 | }; |
||
| 6183 | |||
| 6184 | var isSpanning = function (grid, row, col, comparator) { |
||
| 6185 | var candidate = getCell(grid[row], col); |
||
| 6186 | var matching = curry(comparator, candidate.element); |
||
| 6187 | var currentRow = grid[row]; |
||
| 6188 | return grid.length > 1 && cellLength(currentRow) > 1 && (col > 0 && matching(getCellElement(currentRow, col - 1)) || col < currentRow.cells.length - 1 && matching(getCellElement(currentRow, col + 1)) || row > 0 && matching(getCellElement(grid[row - 1], col)) || row < grid.length - 1 && matching(getCellElement(grid[row + 1], col))); |
||
| 6189 | }; |
||
| 6190 | var mergeTables = function (startAddress, gridA, gridB, generator, comparator, lockedColumns) { |
||
| 6191 | var startRow = startAddress.row; |
||
| 6192 | var startCol = startAddress.column; |
||
| 6193 | var mergeHeight = gridB.length; |
||
| 6194 | var mergeWidth = cellLength(gridB[0]); |
||
| 6195 | var endRow = startRow + mergeHeight; |
||
| 6196 | var endCol = startCol + mergeWidth + lockedColumns.length; |
||
| 6197 | var lockedColumnObj = mapToObject(lockedColumns, always); |
||
| 6198 | for (var r = startRow; r < endRow; r++) { |
||
| 6199 | var skippedCol = 0; |
||
| 6200 | for (var c = startCol; c < endCol; c++) { |
||
| 6201 | if (lockedColumnObj[c]) { |
||
| 6202 | skippedCol++; |
||
| 6203 | continue; |
||
| 6204 | } |
||
| 6205 | if (isSpanning(gridA, r, c, comparator)) { |
||
| 6206 | unmerge(gridA, getCellElement(gridA[r], c), comparator, generator.cell); |
||
| 6207 | } |
||
| 6208 | var gridBColIndex = c - startCol - skippedCol; |
||
| 6209 | var newCell = getCell(gridB[r - startRow], gridBColIndex); |
||
| 6210 | var newCellElm = newCell.element; |
||
| 6211 | var replacement = generator.replace(newCellElm); |
||
| 6212 | mutateCell(gridA[r], c, elementnew(replacement, true, newCell.isLocked)); |
||
| 6213 | } |
||
| 6214 | } |
||
| 6215 | return gridA; |
||
| 6216 | }; |
||
| 6217 | var getValidStartAddress = function (currentStartAddress, grid, lockedColumns) { |
||
| 6218 | var gridColLength = cellLength(grid[0]); |
||
| 637 | daniel-mar | 6219 | var adjustedRowAddress = extractGridDetails(grid).cols.length + currentStartAddress.row; |
| 6220 | var possibleColAddresses = range$1(gridColLength - currentStartAddress.column, function (num) { |
||
| 597 | daniel-mar | 6221 | return num + currentStartAddress.column; |
| 6222 | }); |
||
| 637 | daniel-mar | 6223 | var validColAddress = find$1(possibleColAddresses, function (num) { |
| 597 | daniel-mar | 6224 | return forall(lockedColumns, function (col) { |
| 6225 | return col !== num; |
||
| 6226 | }); |
||
| 6227 | }).getOr(gridColLength - 1); |
||
| 637 | daniel-mar | 6228 | return { |
| 6229 | row: adjustedRowAddress, |
||
| 6230 | column: validColAddress |
||
| 6231 | }; |
||
| 597 | daniel-mar | 6232 | }; |
| 6233 | var getLockedColumnsWithinBounds = function (startAddress, grid, lockedColumns) { |
||
| 637 | daniel-mar | 6234 | return filter$2(lockedColumns, function (colNum) { |
| 597 | daniel-mar | 6235 | return colNum >= startAddress.column && colNum <= cellLength(grid[0]) + startAddress.column; |
| 6236 | }); |
||
| 6237 | }; |
||
| 6238 | var merge$1 = function (startAddress, gridA, gridB, generator, comparator) { |
||
| 6239 | var lockedColumns = getLockedColumnsFromGrid(gridA); |
||
| 6240 | var validStartAddress = getValidStartAddress(startAddress, gridA, lockedColumns); |
||
| 637 | daniel-mar | 6241 | var gridBRows = extractGridDetails(gridB).rows; |
| 6242 | var lockedColumnsWithinBounds = getLockedColumnsWithinBounds(validStartAddress, gridBRows, lockedColumns); |
||
| 6243 | var result = measure(validStartAddress, gridA, gridBRows); |
||
| 597 | daniel-mar | 6244 | return result.map(function (diff) { |
| 6245 | var delta = __assign(__assign({}, diff), { colDelta: diff.colDelta - lockedColumnsWithinBounds.length }); |
||
| 6246 | var fittedGrid = tailor(gridA, delta, generator); |
||
| 6247 | var newLockedColumns = getLockedColumnsFromGrid(fittedGrid); |
||
| 637 | daniel-mar | 6248 | var newLockedColumnsWithinBounds = getLockedColumnsWithinBounds(validStartAddress, gridBRows, newLockedColumns); |
| 6249 | return mergeTables(validStartAddress, fittedGrid, gridBRows, generator, comparator, newLockedColumnsWithinBounds); |
||
| 597 | daniel-mar | 6250 | }); |
| 6251 | }; |
||
| 6252 | var insertCols = function (index, gridA, gridB, generator, comparator) { |
||
| 6253 | splitCols(gridA, index, comparator, generator.cell); |
||
| 6254 | var delta = measureHeight(gridB, gridA); |
||
| 6255 | var fittedNewGrid = tailor(gridB, delta, generator); |
||
| 6256 | var secondDelta = measureHeight(gridA, fittedNewGrid); |
||
| 6257 | var fittedOldGrid = tailor(gridA, secondDelta, generator); |
||
| 637 | daniel-mar | 6258 | return map$1(fittedOldGrid, function (gridRow, i) { |
| 597 | daniel-mar | 6259 | return addCells(gridRow, index, fittedNewGrid[i].cells); |
| 6260 | }); |
||
| 6261 | }; |
||
| 6262 | var insertRows = function (index, gridA, gridB, generator, comparator) { |
||
| 6263 | splitRows(gridA, index, comparator, generator.cell); |
||
| 6264 | var locked = getLockedColumnsFromGrid(gridA); |
||
| 6265 | var diff = measureWidth(gridA, gridB); |
||
| 6266 | var delta = __assign(__assign({}, diff), { colDelta: diff.colDelta - locked.length }); |
||
| 6267 | var fittedOldGrid = tailor(gridA, delta, generator); |
||
| 6268 | var _a = extractGridDetails(fittedOldGrid), oldCols = _a.cols, oldRows = _a.rows; |
||
| 6269 | var newLocked = getLockedColumnsFromGrid(fittedOldGrid); |
||
| 6270 | var secondDiff = measureWidth(gridB, gridA); |
||
| 6271 | var secondDelta = __assign(__assign({}, secondDiff), { colDelta: secondDiff.colDelta + newLocked.length }); |
||
| 6272 | var fittedGridB = lockedColFill(gridB, generator, newLocked); |
||
| 6273 | var fittedNewGrid = tailor(fittedGridB, secondDelta, generator); |
||
| 6274 | return oldCols.concat(oldRows.slice(0, index)).concat(fittedNewGrid).concat(oldRows.slice(index, oldRows.length)); |
||
| 6275 | }; |
||
| 6276 | |||
| 637 | daniel-mar | 6277 | var cloneRow = function (row, cloneCell, comparator, substitution) { |
| 6278 | return clone$1(row, function (elem) { |
||
| 6279 | return substitution(elem, comparator); |
||
| 6280 | }, cloneCell); |
||
| 6281 | }; |
||
| 597 | daniel-mar | 6282 | var insertRowAt = function (grid, index, example, comparator, substitution) { |
| 6283 | var _a = extractGridDetails(grid), rows = _a.rows, cols = _a.cols; |
||
| 6284 | var before = rows.slice(0, index); |
||
| 6285 | var after = rows.slice(index); |
||
| 637 | daniel-mar | 6286 | var newRow = cloneRow(rows[example], function (ex, c) { |
| 597 | daniel-mar | 6287 | var withinSpan = index > 0 && index < rows.length && comparator(getCellElement(rows[index - 1], c), getCellElement(rows[index], c)); |
| 6288 | var ret = withinSpan ? getCell(rows[index], c) : elementnew(substitution(ex.element, comparator), true, ex.isLocked); |
||
| 6289 | return ret; |
||
| 637 | daniel-mar | 6290 | }, comparator, substitution); |
| 6291 | return cols.concat(before).concat([newRow]).concat(after); |
||
| 597 | daniel-mar | 6292 | }; |
| 6293 | var getElementFor = function (row, column, section, withinSpan, example, comparator, substitution) { |
||
| 6294 | if (section === 'colgroup' || !withinSpan) { |
||
| 6295 | var cell = getCell(row, example); |
||
| 6296 | return elementnew(substitution(cell.element, comparator), true, false); |
||
| 6297 | } else { |
||
| 6298 | return getCell(row, column); |
||
| 6299 | } |
||
| 6300 | }; |
||
| 6301 | var insertColumnAt = function (grid, index, example, comparator, substitution) { |
||
| 637 | daniel-mar | 6302 | return map$1(grid, function (row) { |
| 597 | daniel-mar | 6303 | var withinSpan = index > 0 && index < cellLength(row) && comparator(getCellElement(row, index - 1), getCellElement(row, index)); |
| 6304 | var sub = getElementFor(row, index, row.section, withinSpan, example, comparator, substitution); |
||
| 6305 | return addCell(row, index, sub); |
||
| 6306 | }); |
||
| 6307 | }; |
||
| 6308 | var deleteColumnsAt = function (grid, columns) { |
||
| 637 | daniel-mar | 6309 | return bind$2(grid, function (row) { |
| 597 | daniel-mar | 6310 | var existingCells = row.cells; |
| 6311 | var cells = foldr(columns, function (acc, column) { |
||
| 6312 | return column >= 0 && column < acc.length ? acc.slice(0, column).concat(acc.slice(column + 1)) : acc; |
||
| 6313 | }, existingCells); |
||
| 637 | daniel-mar | 6314 | return cells.length > 0 ? [rowcells(row.element, cells, row.section, row.isNew)] : []; |
| 597 | daniel-mar | 6315 | }); |
| 6316 | }; |
||
| 6317 | var deleteRowsAt = function (grid, start, finish) { |
||
| 6318 | var _a = extractGridDetails(grid), rows = _a.rows, cols = _a.cols; |
||
| 6319 | return cols.concat(rows.slice(0, start)).concat(rows.slice(finish + 1)); |
||
| 6320 | }; |
||
| 6321 | |||
| 679 | daniel-mar | 6322 | var notInStartRow = function (grid, rowIndex, colIndex, comparator) { |
| 6323 | return getCellElement(grid[rowIndex], colIndex) !== undefined && (rowIndex > 0 && comparator(getCellElement(grid[rowIndex - 1], colIndex), getCellElement(grid[rowIndex], colIndex))); |
||
| 6324 | }; |
||
| 6325 | var notInStartColumn = function (row, index, comparator) { |
||
| 6326 | return index > 0 && comparator(getCellElement(row, index - 1), getCellElement(row, index)); |
||
| 6327 | }; |
||
| 6328 | var isDuplicatedCell = function (grid, rowIndex, colIndex, comparator) { |
||
| 6329 | return notInStartRow(grid, rowIndex, colIndex, comparator) || notInStartColumn(grid[rowIndex], colIndex, comparator); |
||
| 6330 | }; |
||
| 6331 | var rowReplacerPredicate = function (targetRow, columnHeaders) { |
||
| 6332 | var entireTableIsHeader = forall(columnHeaders, identity) && isHeaderCells(targetRow.cells); |
||
| 6333 | return entireTableIsHeader ? always : function (cell, _rowIndex, colIndex) { |
||
| 6334 | var type = name(cell.element); |
||
| 6335 | return !(type === 'th' && columnHeaders[colIndex]); |
||
| 6336 | }; |
||
| 6337 | }; |
||
| 6338 | var columnReplacePredicate = function (targetColumn, rowHeaders) { |
||
| 6339 | var entireTableIsHeader = forall(rowHeaders, identity) && isHeaderCells(targetColumn); |
||
| 6340 | return entireTableIsHeader ? always : function (cell, rowIndex, _colIndex) { |
||
| 6341 | var type = name(cell.element); |
||
| 6342 | return !(type === 'th' && rowHeaders[rowIndex]); |
||
| 6343 | }; |
||
| 6344 | }; |
||
| 6345 | var determineScope = function (applyScope, element, newScope, isInHeader) { |
||
| 6346 | var hasSpan = function (scope) { |
||
| 6347 | return scope === 'row' ? hasRowspan(element) : hasColspan(element); |
||
| 6348 | }; |
||
| 6349 | var getScope = function (scope) { |
||
| 6350 | return hasSpan(scope) ? scope + 'group' : scope; |
||
| 6351 | }; |
||
| 6352 | if (applyScope) { |
||
| 6353 | return isHeaderCell(element) ? getScope(newScope) : null; |
||
| 6354 | } else if (isInHeader && isHeaderCell(element)) { |
||
| 6355 | var oppositeScope = newScope === 'row' ? 'col' : 'row'; |
||
| 6356 | return getScope(oppositeScope); |
||
| 6357 | } else { |
||
| 6358 | return null; |
||
| 6359 | } |
||
| 6360 | }; |
||
| 6361 | var rowScopeGenerator = function (applyScope, columnHeaders) { |
||
| 6362 | return function (cell, rowIndex, columnIndex) { |
||
| 6363 | return Optional.some(determineScope(applyScope, cell.element, 'col', columnHeaders[columnIndex])); |
||
| 6364 | }; |
||
| 6365 | }; |
||
| 6366 | var columnScopeGenerator = function (applyScope, rowHeaders) { |
||
| 6367 | return function (cell, rowIndex) { |
||
| 6368 | return Optional.some(determineScope(applyScope, cell.element, 'row', rowHeaders[rowIndex])); |
||
| 6369 | }; |
||
| 6370 | }; |
||
| 637 | daniel-mar | 6371 | var replace = function (cell, comparator, substitute) { |
| 6372 | return elementnew(substitute(cell.element, comparator), true, cell.isLocked); |
||
| 6373 | }; |
||
| 679 | daniel-mar | 6374 | var replaceIn = function (grid, targets, comparator, substitute, replacer, genScope, shouldReplace) { |
| 597 | daniel-mar | 6375 | var isTarget = function (cell) { |
| 6376 | return exists(targets, function (target) { |
||
| 6377 | return comparator(cell.element, target.element); |
||
| 6378 | }); |
||
| 6379 | }; |
||
| 679 | daniel-mar | 6380 | return map$1(grid, function (row, rowIndex) { |
| 6381 | return mapCells(row, function (cell, colIndex) { |
||
| 6382 | if (isTarget(cell)) { |
||
| 6383 | var newCell_1 = shouldReplace(cell, rowIndex, colIndex) ? replacer(cell, comparator, substitute) : cell; |
||
| 6384 | genScope(newCell_1, rowIndex, colIndex).each(function (scope) { |
||
| 6385 | setOptions(newCell_1.element, { scope: Optional.from(scope) }); |
||
| 6386 | }); |
||
| 6387 | return newCell_1; |
||
| 6388 | } else { |
||
| 6389 | return cell; |
||
| 6390 | } |
||
| 597 | daniel-mar | 6391 | }); |
| 6392 | }); |
||
| 6393 | }; |
||
| 679 | daniel-mar | 6394 | var getColumnCells = function (rows, columnIndex, comparator) { |
| 6395 | return bind$2(rows, function (row, i) { |
||
| 6396 | return isDuplicatedCell(rows, i, columnIndex, comparator) ? [] : [getCell(row, columnIndex)]; |
||
| 6397 | }); |
||
| 597 | daniel-mar | 6398 | }; |
| 679 | daniel-mar | 6399 | var getRowCells = function (rows, rowIndex, comparator) { |
| 6400 | var targetRow = rows[rowIndex]; |
||
| 6401 | return bind$2(targetRow.cells, function (item, i) { |
||
| 6402 | return isDuplicatedCell(rows, rowIndex, i, comparator) ? [] : [item]; |
||
| 6403 | }); |
||
| 597 | daniel-mar | 6404 | }; |
| 679 | daniel-mar | 6405 | var replaceColumns = function (grid, indexes, applyScope, comparator, substitution) { |
| 597 | daniel-mar | 6406 | var rows = extractGridDetails(grid).rows; |
| 679 | daniel-mar | 6407 | var targets = bind$2(indexes, function (index) { |
| 6408 | return getColumnCells(rows, index, comparator); |
||
| 597 | daniel-mar | 6409 | }); |
| 679 | daniel-mar | 6410 | var rowHeaders = map$1(grid, function (row) { |
| 6411 | return isHeaderCells(row.cells); |
||
| 6412 | }); |
||
| 6413 | var shouldReplaceCell = columnReplacePredicate(targets, rowHeaders); |
||
| 6414 | var scopeGenerator = columnScopeGenerator(applyScope, rowHeaders); |
||
| 6415 | return replaceIn(grid, targets, comparator, substitution, replace, scopeGenerator, shouldReplaceCell); |
||
| 597 | daniel-mar | 6416 | }; |
| 679 | daniel-mar | 6417 | var replaceRows = function (grid, indexes, section, applyScope, comparator, substitution, tableSection) { |
| 637 | daniel-mar | 6418 | var _a = extractGridDetails(grid), cols = _a.cols, rows = _a.rows; |
| 679 | daniel-mar | 6419 | var targetRow = rows[indexes[0]]; |
| 6420 | var targets = bind$2(indexes, function (index) { |
||
| 6421 | return getRowCells(rows, index, comparator); |
||
| 597 | daniel-mar | 6422 | }); |
| 679 | daniel-mar | 6423 | var columnHeaders = map$1(targetRow.cells, function (_cell, index) { |
| 6424 | return isHeaderCells(getColumnCells(rows, index, comparator)); |
||
| 6425 | }); |
||
| 6426 | var newRows = __spreadArray([], rows, true); |
||
| 6427 | each$2(indexes, function (index) { |
||
| 6428 | newRows[index] = tableSection.transformRow(rows[index], section); |
||
| 6429 | }); |
||
| 6430 | var newGrid = cols.concat(newRows); |
||
| 6431 | var shouldReplaceCell = rowReplacerPredicate(targetRow, columnHeaders); |
||
| 6432 | var scopeGenerator = rowScopeGenerator(applyScope, columnHeaders); |
||
| 6433 | return replaceIn(newGrid, targets, comparator, substitution, tableSection.transformCell, scopeGenerator, shouldReplaceCell); |
||
| 597 | daniel-mar | 6434 | }; |
| 679 | daniel-mar | 6435 | var replaceCells = function (grid, details, comparator, substitution) { |
| 637 | daniel-mar | 6436 | var rows = extractGridDetails(grid).rows; |
| 679 | daniel-mar | 6437 | var targetCells = map$1(details, function (detail) { |
| 6438 | return getCell(rows[detail.row], detail.column); |
||
| 6439 | }); |
||
| 6440 | return replaceIn(grid, targetCells, comparator, substitution, replace, Optional.none, always); |
||
| 637 | daniel-mar | 6441 | }; |
| 597 | daniel-mar | 6442 | |
| 6443 | var uniqueColumns = function (details) { |
||
| 6444 | var uniqueCheck = function (rest, detail) { |
||
| 6445 | var columnExists = exists(rest, function (currentDetail) { |
||
| 6446 | return currentDetail.column === detail.column; |
||
| 6447 | }); |
||
| 6448 | return columnExists ? rest : rest.concat([detail]); |
||
| 6449 | }; |
||
| 6450 | return foldl(details, uniqueCheck, []).sort(function (detailA, detailB) { |
||
| 6451 | return detailA.column - detailB.column; |
||
| 6452 | }); |
||
| 6453 | }; |
||
| 6454 | |||
| 637 | daniel-mar | 6455 | var isCol = isTag('col'); |
| 6456 | var isColgroup = isTag('colgroup'); |
||
| 6457 | var isRow$1 = function (element) { |
||
| 6458 | return name(element) === 'tr' || isColgroup(element); |
||
| 6459 | }; |
||
| 597 | daniel-mar | 6460 | var elementToData = function (element) { |
| 6461 | var colspan = getAttrValue(element, 'colspan', 1); |
||
| 6462 | var rowspan = getAttrValue(element, 'rowspan', 1); |
||
| 6463 | return { |
||
| 6464 | element: element, |
||
| 6465 | colspan: colspan, |
||
| 6466 | rowspan: rowspan |
||
| 6467 | }; |
||
| 6468 | }; |
||
| 6469 | var modification = function (generators, toData) { |
||
| 6470 | if (toData === void 0) { |
||
| 6471 | toData = elementToData; |
||
| 6472 | } |
||
| 637 | daniel-mar | 6473 | var nuCell = function (data) { |
| 6474 | return isCol(data.element) ? generators.col(data) : generators.cell(data); |
||
| 597 | daniel-mar | 6475 | }; |
| 637 | daniel-mar | 6476 | var nuRow = function (data) { |
| 6477 | return isColgroup(data.element) ? generators.colgroup(data) : generators.row(data); |
||
| 597 | daniel-mar | 6478 | }; |
| 6479 | var add = function (element) { |
||
| 637 | daniel-mar | 6480 | if (isRow$1(element)) { |
| 6481 | return nuRow({ element: element }); |
||
| 6482 | } else { |
||
| 6483 | var replacement = nuCell(toData(element)); |
||
| 6484 | recent = Optional.some({ |
||
| 6485 | item: element, |
||
| 6486 | replacement: replacement |
||
| 6487 | }); |
||
| 6488 | return replacement; |
||
| 597 | daniel-mar | 6489 | } |
| 6490 | }; |
||
| 6491 | var recent = Optional.none(); |
||
| 6492 | var getOrInit = function (element, comparator) { |
||
| 6493 | return recent.fold(function () { |
||
| 6494 | return add(element); |
||
| 6495 | }, function (p) { |
||
| 6496 | return comparator(element, p.item) ? p.replacement : add(element); |
||
| 6497 | }); |
||
| 6498 | }; |
||
| 637 | daniel-mar | 6499 | return { getOrInit: getOrInit }; |
| 597 | daniel-mar | 6500 | }; |
| 679 | daniel-mar | 6501 | var transform = function (tag) { |
| 597 | daniel-mar | 6502 | return function (generators) { |
| 6503 | var list = []; |
||
| 637 | daniel-mar | 6504 | var find = function (element, comparator) { |
| 6505 | return find$1(list, function (x) { |
||
| 597 | daniel-mar | 6506 | return comparator(x.item, element); |
| 6507 | }); |
||
| 6508 | }; |
||
| 6509 | var makeNew = function (element) { |
||
| 679 | daniel-mar | 6510 | var attrs = tag === 'td' ? { scope: null } : {}; |
| 597 | daniel-mar | 6511 | var cell = generators.replace(element, tag, attrs); |
| 6512 | list.push({ |
||
| 6513 | item: element, |
||
| 6514 | sub: cell |
||
| 6515 | }); |
||
| 6516 | return cell; |
||
| 6517 | }; |
||
| 6518 | var replaceOrInit = function (element, comparator) { |
||
| 637 | daniel-mar | 6519 | if (isRow$1(element) || isCol(element)) { |
| 597 | daniel-mar | 6520 | return element; |
| 6521 | } else { |
||
| 637 | daniel-mar | 6522 | return find(element, comparator).fold(function () { |
| 597 | daniel-mar | 6523 | return makeNew(element); |
| 6524 | }, function (p) { |
||
| 6525 | return comparator(element, p.item) ? p.sub : makeNew(element); |
||
| 6526 | }); |
||
| 6527 | } |
||
| 6528 | }; |
||
| 637 | daniel-mar | 6529 | return { replaceOrInit: replaceOrInit }; |
| 597 | daniel-mar | 6530 | }; |
| 6531 | }; |
||
| 6532 | var getScopeAttribute = function (cell) { |
||
| 6533 | return getOpt(cell, 'scope').map(function (attribute) { |
||
| 6534 | return attribute.substr(0, 3); |
||
| 6535 | }); |
||
| 6536 | }; |
||
| 6537 | var merging = function (generators) { |
||
| 6538 | var unmerge = function (cell) { |
||
| 6539 | var scope = getScopeAttribute(cell); |
||
| 6540 | scope.each(function (attribute) { |
||
| 637 | daniel-mar | 6541 | return set$2(cell, 'scope', attribute); |
| 597 | daniel-mar | 6542 | }); |
| 6543 | return function () { |
||
| 6544 | var raw = generators.cell({ |
||
| 6545 | element: cell, |
||
| 6546 | colspan: 1, |
||
| 6547 | rowspan: 1 |
||
| 6548 | }); |
||
| 637 | daniel-mar | 6549 | remove$6(raw, 'width'); |
| 6550 | remove$6(cell, 'width'); |
||
| 597 | daniel-mar | 6551 | scope.each(function (attribute) { |
| 637 | daniel-mar | 6552 | return set$2(raw, 'scope', attribute); |
| 597 | daniel-mar | 6553 | }); |
| 6554 | return raw; |
||
| 6555 | }; |
||
| 6556 | }; |
||
| 6557 | var merge = function (cells) { |
||
| 6558 | var getScopeProperty = function () { |
||
| 637 | daniel-mar | 6559 | var stringAttributes = cat(map$1(cells, getScopeAttribute)); |
| 597 | daniel-mar | 6560 | if (stringAttributes.length === 0) { |
| 6561 | return Optional.none(); |
||
| 6562 | } else { |
||
| 6563 | var baseScope_1 = stringAttributes[0]; |
||
| 6564 | var scopes_1 = [ |
||
| 6565 | 'row', |
||
| 6566 | 'col' |
||
| 6567 | ]; |
||
| 6568 | var isMixed = exists(stringAttributes, function (attribute) { |
||
| 637 | daniel-mar | 6569 | return attribute !== baseScope_1 && contains$2(scopes_1, attribute); |
| 597 | daniel-mar | 6570 | }); |
| 6571 | return isMixed ? Optional.none() : Optional.from(baseScope_1); |
||
| 6572 | } |
||
| 6573 | }; |
||
| 637 | daniel-mar | 6574 | remove$6(cells[0], 'width'); |
| 597 | daniel-mar | 6575 | getScopeProperty().fold(function () { |
| 637 | daniel-mar | 6576 | return remove$7(cells[0], 'scope'); |
| 597 | daniel-mar | 6577 | }, function (attribute) { |
| 637 | daniel-mar | 6578 | return set$2(cells[0], 'scope', attribute + 'group'); |
| 597 | daniel-mar | 6579 | }); |
| 6580 | return constant(cells[0]); |
||
| 6581 | }; |
||
| 6582 | return { |
||
| 6583 | unmerge: unmerge, |
||
| 637 | daniel-mar | 6584 | merge: merge |
| 597 | daniel-mar | 6585 | }; |
| 6586 | }; |
||
| 6587 | var Generators = { |
||
| 6588 | modification: modification, |
||
| 637 | daniel-mar | 6589 | transform: transform, |
| 597 | daniel-mar | 6590 | merging: merging |
| 6591 | }; |
||
| 6592 | |||
| 6593 | var blockList = [ |
||
| 6594 | 'body', |
||
| 6595 | 'p', |
||
| 6596 | 'div', |
||
| 6597 | 'article', |
||
| 6598 | 'aside', |
||
| 6599 | 'figcaption', |
||
| 6600 | 'figure', |
||
| 6601 | 'footer', |
||
| 6602 | 'header', |
||
| 6603 | 'nav', |
||
| 6604 | 'section', |
||
| 6605 | 'ol', |
||
| 6606 | 'ul', |
||
| 6607 | 'table', |
||
| 6608 | 'thead', |
||
| 6609 | 'tfoot', |
||
| 6610 | 'tbody', |
||
| 6611 | 'caption', |
||
| 6612 | 'tr', |
||
| 6613 | 'td', |
||
| 6614 | 'th', |
||
| 6615 | 'h1', |
||
| 6616 | 'h2', |
||
| 6617 | 'h3', |
||
| 6618 | 'h4', |
||
| 6619 | 'h5', |
||
| 6620 | 'h6', |
||
| 6621 | 'blockquote', |
||
| 6622 | 'pre', |
||
| 6623 | 'address' |
||
| 6624 | ]; |
||
| 637 | daniel-mar | 6625 | var isList$1 = function (universe, item) { |
| 597 | daniel-mar | 6626 | var tagName = universe.property().name(item); |
| 637 | daniel-mar | 6627 | return contains$2([ |
| 597 | daniel-mar | 6628 | 'ol', |
| 6629 | 'ul' |
||
| 6630 | ], tagName); |
||
| 6631 | }; |
||
| 637 | daniel-mar | 6632 | var isBlock$1 = function (universe, item) { |
| 597 | daniel-mar | 6633 | var tagName = universe.property().name(item); |
| 637 | daniel-mar | 6634 | return contains$2(blockList, tagName); |
| 597 | daniel-mar | 6635 | }; |
| 637 | daniel-mar | 6636 | var isEmptyTag$1 = function (universe, item) { |
| 6637 | return contains$2([ |
||
| 597 | daniel-mar | 6638 | 'br', |
| 6639 | 'img', |
||
| 6640 | 'hr', |
||
| 6641 | 'input' |
||
| 6642 | ], universe.property().name(item)); |
||
| 6643 | }; |
||
| 6644 | |||
| 637 | daniel-mar | 6645 | var universe$1 = DomUniverse(); |
| 6646 | var isBlock = function (element) { |
||
| 6647 | return isBlock$1(universe$1, element); |
||
| 597 | daniel-mar | 6648 | }; |
| 637 | daniel-mar | 6649 | var isList = function (element) { |
| 6650 | return isList$1(universe$1, element); |
||
| 597 | daniel-mar | 6651 | }; |
| 637 | daniel-mar | 6652 | var isEmptyTag = function (element) { |
| 6653 | return isEmptyTag$1(universe$1, element); |
||
| 597 | daniel-mar | 6654 | }; |
| 6655 | |||
| 637 | daniel-mar | 6656 | var merge = function (cells) { |
| 597 | daniel-mar | 6657 | var isBr = function (el) { |
| 6658 | return name(el) === 'br'; |
||
| 6659 | }; |
||
| 6660 | var advancedBr = function (children) { |
||
| 6661 | return forall(children, function (c) { |
||
| 637 | daniel-mar | 6662 | return isBr(c) || isText(c) && get$9(c).trim().length === 0; |
| 597 | daniel-mar | 6663 | }); |
| 6664 | }; |
||
| 6665 | var isListItem = function (el) { |
||
| 637 | daniel-mar | 6666 | return name(el) === 'li' || ancestor$2(el, isList).isSome(); |
| 597 | daniel-mar | 6667 | }; |
| 6668 | var siblingIsBlock = function (el) { |
||
| 6669 | return nextSibling(el).map(function (rightSibling) { |
||
| 637 | daniel-mar | 6670 | if (isBlock(rightSibling)) { |
| 597 | daniel-mar | 6671 | return true; |
| 6672 | } |
||
| 637 | daniel-mar | 6673 | if (isEmptyTag(rightSibling)) { |
| 597 | daniel-mar | 6674 | return name(rightSibling) === 'img' ? false : true; |
| 6675 | } |
||
| 6676 | return false; |
||
| 6677 | }).getOr(false); |
||
| 6678 | }; |
||
| 6679 | var markCell = function (cell) { |
||
| 6680 | return last$1(cell).bind(function (rightEdge) { |
||
| 6681 | var rightSiblingIsBlock = siblingIsBlock(rightEdge); |
||
| 6682 | return parent(rightEdge).map(function (parent) { |
||
| 637 | daniel-mar | 6683 | return rightSiblingIsBlock === true || isListItem(parent) || isBr(rightEdge) || isBlock(parent) && !eq$1(cell, parent) ? [] : [SugarElement.fromTag('br')]; |
| 597 | daniel-mar | 6684 | }); |
| 6685 | }).getOr([]); |
||
| 6686 | }; |
||
| 6687 | var markContent = function () { |
||
| 637 | daniel-mar | 6688 | var content = bind$2(cells, function (cell) { |
| 6689 | var children = children$3(cell); |
||
| 6690 | return advancedBr(children) ? [] : children.concat(markCell(cell)); |
||
| 597 | daniel-mar | 6691 | }); |
| 6692 | return content.length === 0 ? [SugarElement.fromTag('br')] : content; |
||
| 6693 | }; |
||
| 6694 | var contents = markContent(); |
||
| 6695 | empty(cells[0]); |
||
| 637 | daniel-mar | 6696 | append(cells[0], contents); |
| 597 | daniel-mar | 6697 | }; |
| 6698 | |||
| 637 | daniel-mar | 6699 | var isEditable = function (elem) { |
| 6700 | return isEditable$1(elem, true); |
||
| 6701 | }; |
||
| 597 | daniel-mar | 6702 | var prune = function (table) { |
| 637 | daniel-mar | 6703 | var cells = cells$1(table); |
| 6704 | if (cells.length === 0) { |
||
| 6705 | remove$5(table); |
||
| 597 | daniel-mar | 6706 | } |
| 6707 | }; |
||
| 6708 | var outcome = function (grid, cursor) { |
||
| 6709 | return { |
||
| 6710 | grid: grid, |
||
| 6711 | cursor: cursor |
||
| 6712 | }; |
||
| 6713 | }; |
||
| 637 | daniel-mar | 6714 | var findEditableCursorPosition = function (rows) { |
| 6715 | return findMap(rows, function (row) { |
||
| 6716 | return findMap(row.cells, function (cell) { |
||
| 6717 | var elem = cell.element; |
||
| 6718 | return someIf(isEditable(elem), elem); |
||
| 6719 | }); |
||
| 6720 | }); |
||
| 6721 | }; |
||
| 597 | daniel-mar | 6722 | var elementFromGrid = function (grid, row, column) { |
| 637 | daniel-mar | 6723 | var _a, _b; |
| 597 | daniel-mar | 6724 | var rows = extractGridDetails(grid).rows; |
| 637 | daniel-mar | 6725 | return Optional.from((_b = (_a = rows[row]) === null || _a === void 0 ? void 0 : _a.cells[column]) === null || _b === void 0 ? void 0 : _b.element).filter(isEditable).orThunk(function () { |
| 6726 | return findEditableCursorPosition(rows); |
||
| 597 | daniel-mar | 6727 | }); |
| 6728 | }; |
||
| 6729 | var bundle = function (grid, row, column) { |
||
| 637 | daniel-mar | 6730 | var cursorElement = elementFromGrid(grid, row, column); |
| 6731 | return outcome(grid, cursorElement); |
||
| 597 | daniel-mar | 6732 | }; |
| 6733 | var uniqueRows = function (details) { |
||
| 6734 | var rowCompilation = function (rest, detail) { |
||
| 6735 | var rowExists = exists(rest, function (currentDetail) { |
||
| 6736 | return currentDetail.row === detail.row; |
||
| 6737 | }); |
||
| 6738 | return rowExists ? rest : rest.concat([detail]); |
||
| 6739 | }; |
||
| 6740 | return foldl(details, rowCompilation, []).sort(function (detailA, detailB) { |
||
| 6741 | return detailA.row - detailB.row; |
||
| 6742 | }); |
||
| 6743 | }; |
||
| 6744 | var opInsertRowsBefore = function (grid, details, comparator, genWrappers) { |
||
| 6745 | var targetIndex = details[0].row; |
||
| 6746 | var rows = uniqueRows(details); |
||
| 6747 | var newGrid = foldr(rows, function (acc, row) { |
||
| 6748 | var newG = insertRowAt(acc.grid, targetIndex, row.row + acc.delta, comparator, genWrappers.getOrInit); |
||
| 6749 | return { |
||
| 6750 | grid: newG, |
||
| 6751 | delta: acc.delta + 1 |
||
| 6752 | }; |
||
| 6753 | }, { |
||
| 6754 | grid: grid, |
||
| 6755 | delta: 0 |
||
| 6756 | }).grid; |
||
| 6757 | return bundle(newGrid, targetIndex, details[0].column); |
||
| 6758 | }; |
||
| 6759 | var opInsertRowsAfter = function (grid, details, comparator, genWrappers) { |
||
| 6760 | var rows = uniqueRows(details); |
||
| 6761 | var target = rows[rows.length - 1]; |
||
| 6762 | var targetIndex = target.row + target.rowspan; |
||
| 6763 | var newGrid = foldr(rows, function (newG, row) { |
||
| 6764 | return insertRowAt(newG, targetIndex, row.row, comparator, genWrappers.getOrInit); |
||
| 6765 | }, grid); |
||
| 6766 | return bundle(newGrid, targetIndex, details[0].column); |
||
| 6767 | }; |
||
| 6768 | var opInsertColumnsBefore = function (grid, extractDetail, comparator, genWrappers) { |
||
| 6769 | var details = extractDetail.details; |
||
| 6770 | var columns = uniqueColumns(details); |
||
| 6771 | var targetIndex = columns[0].column; |
||
| 6772 | var newGrid = foldr(columns, function (acc, col) { |
||
| 6773 | var newG = insertColumnAt(acc.grid, targetIndex, col.column + acc.delta, comparator, genWrappers.getOrInit); |
||
| 6774 | return { |
||
| 6775 | grid: newG, |
||
| 6776 | delta: acc.delta + 1 |
||
| 6777 | }; |
||
| 6778 | }, { |
||
| 6779 | grid: grid, |
||
| 6780 | delta: 0 |
||
| 6781 | }).grid; |
||
| 6782 | return bundle(newGrid, details[0].row, targetIndex); |
||
| 6783 | }; |
||
| 6784 | var opInsertColumnsAfter = function (grid, extractDetail, comparator, genWrappers) { |
||
| 6785 | var details = extractDetail.details; |
||
| 6786 | var target = details[details.length - 1]; |
||
| 6787 | var targetIndex = target.column + target.colspan; |
||
| 6788 | var columns = uniqueColumns(details); |
||
| 6789 | var newGrid = foldr(columns, function (newG, col) { |
||
| 6790 | return insertColumnAt(newG, targetIndex, col.column, comparator, genWrappers.getOrInit); |
||
| 6791 | }, grid); |
||
| 6792 | return bundle(newGrid, details[0].row, targetIndex); |
||
| 6793 | }; |
||
| 6794 | var opMakeColumnsHeader = function (initialGrid, details, comparator, genWrappers) { |
||
| 637 | daniel-mar | 6795 | var columns = uniqueColumns(details); |
| 679 | daniel-mar | 6796 | var columnIndexes = map$1(columns, function (detail) { |
| 6797 | return detail.column; |
||
| 6798 | }); |
||
| 6799 | var newGrid = replaceColumns(initialGrid, columnIndexes, true, comparator, genWrappers.replaceOrInit); |
||
| 597 | daniel-mar | 6800 | return bundle(newGrid, details[0].row, details[0].column); |
| 6801 | }; |
||
| 637 | daniel-mar | 6802 | var opMakeCellsHeader = function (initialGrid, details, comparator, genWrappers) { |
| 679 | daniel-mar | 6803 | var newGrid = replaceCells(initialGrid, details, comparator, genWrappers.replaceOrInit); |
| 597 | daniel-mar | 6804 | return bundle(newGrid, details[0].row, details[0].column); |
| 6805 | }; |
||
| 6806 | var opUnmakeColumnsHeader = function (initialGrid, details, comparator, genWrappers) { |
||
| 637 | daniel-mar | 6807 | var columns = uniqueColumns(details); |
| 679 | daniel-mar | 6808 | var columnIndexes = map$1(columns, function (detail) { |
| 6809 | return detail.column; |
||
| 6810 | }); |
||
| 6811 | var newGrid = replaceColumns(initialGrid, columnIndexes, false, comparator, genWrappers.replaceOrInit); |
||
| 597 | daniel-mar | 6812 | return bundle(newGrid, details[0].row, details[0].column); |
| 6813 | }; |
||
| 637 | daniel-mar | 6814 | var opUnmakeCellsHeader = function (initialGrid, details, comparator, genWrappers) { |
| 679 | daniel-mar | 6815 | var newGrid = replaceCells(initialGrid, details, comparator, genWrappers.replaceOrInit); |
| 637 | daniel-mar | 6816 | return bundle(newGrid, details[0].row, details[0].column); |
| 6817 | }; |
||
| 679 | daniel-mar | 6818 | var makeRowsSection = function (section, applyScope) { |
| 637 | daniel-mar | 6819 | return function (initialGrid, details, comparator, genWrappers, tableSection) { |
| 6820 | var rows = uniqueRows(details); |
||
| 679 | daniel-mar | 6821 | var rowIndexes = map$1(rows, function (detail) { |
| 6822 | return detail.row; |
||
| 6823 | }); |
||
| 6824 | var newGrid = replaceRows(initialGrid, rowIndexes, section, applyScope, comparator, genWrappers.replaceOrInit, tableSection); |
||
| 637 | daniel-mar | 6825 | return bundle(newGrid, details[0].row, details[0].column); |
| 6826 | }; |
||
| 6827 | }; |
||
| 679 | daniel-mar | 6828 | var opMakeRowsHeader = makeRowsSection('thead', true); |
| 6829 | var opMakeRowsBody = makeRowsSection('tbody', false); |
||
| 6830 | var opMakeRowsFooter = makeRowsSection('tfoot', false); |
||
| 597 | daniel-mar | 6831 | var opEraseColumns = function (grid, extractDetail, _comparator, _genWrappers) { |
| 6832 | var columns = uniqueColumns(extractDetail.details); |
||
| 637 | daniel-mar | 6833 | var newGrid = deleteColumnsAt(grid, map$1(columns, function (column) { |
| 597 | daniel-mar | 6834 | return column.column; |
| 6835 | })); |
||
| 637 | daniel-mar | 6836 | var maxColIndex = newGrid.length > 0 ? newGrid[0].cells.length - 1 : 0; |
| 6837 | return bundle(newGrid, columns[0].row, Math.min(columns[0].column, maxColIndex)); |
||
| 597 | daniel-mar | 6838 | }; |
| 6839 | var opEraseRows = function (grid, details, _comparator, _genWrappers) { |
||
| 6840 | var rows = uniqueRows(details); |
||
| 6841 | var newGrid = deleteRowsAt(grid, rows[0].row, rows[rows.length - 1].row); |
||
| 637 | daniel-mar | 6842 | var maxRowIndex = newGrid.length > 0 ? newGrid.length - 1 : 0; |
| 6843 | return bundle(newGrid, Math.min(details[0].row, maxRowIndex), details[0].column); |
||
| 597 | daniel-mar | 6844 | }; |
| 6845 | var opMergeCells = function (grid, mergable, comparator, genWrappers) { |
||
| 6846 | var cells = mergable.cells; |
||
| 637 | daniel-mar | 6847 | merge(cells); |
| 6848 | var newGrid = merge$2(grid, mergable.bounds, comparator, genWrappers.merge(cells)); |
||
| 597 | daniel-mar | 6849 | return outcome(newGrid, Optional.from(cells[0])); |
| 6850 | }; |
||
| 6851 | var opUnmergeCells = function (grid, unmergable, comparator, genWrappers) { |
||
| 6852 | var unmerge$1 = function (b, cell) { |
||
| 6853 | return unmerge(b, cell, comparator, genWrappers.unmerge(cell)); |
||
| 6854 | }; |
||
| 6855 | var newGrid = foldr(unmergable, unmerge$1, grid); |
||
| 6856 | return outcome(newGrid, Optional.from(unmergable[0])); |
||
| 6857 | }; |
||
| 6858 | var opPasteCells = function (grid, pasteDetails, comparator, _genWrappers) { |
||
| 6859 | var gridify = function (table, generators) { |
||
| 6860 | var wh = Warehouse.fromTable(table); |
||
| 6861 | return toGrid(wh, generators, true); |
||
| 6862 | }; |
||
| 6863 | var gridB = gridify(pasteDetails.clipboard, pasteDetails.generators); |
||
| 6864 | var startAddress = address(pasteDetails.row, pasteDetails.column); |
||
| 6865 | var mergedGrid = merge$1(startAddress, grid, gridB, pasteDetails.generators, comparator); |
||
| 6866 | return mergedGrid.fold(function () { |
||
| 6867 | return outcome(grid, Optional.some(pasteDetails.element)); |
||
| 6868 | }, function (newGrid) { |
||
| 637 | daniel-mar | 6869 | return bundle(newGrid, pasteDetails.row, pasteDetails.column); |
| 597 | daniel-mar | 6870 | }); |
| 6871 | }; |
||
| 6872 | var gridifyRows = function (rows, generators, context) { |
||
| 6873 | var pasteDetails = fromPastedRows(rows, context.section); |
||
| 6874 | var wh = Warehouse.generate(pasteDetails); |
||
| 6875 | return toGrid(wh, generators, true); |
||
| 6876 | }; |
||
| 6877 | var opPasteColsBefore = function (grid, pasteDetails, comparator, _genWrappers) { |
||
| 6878 | var rows = extractGridDetails(grid).rows; |
||
| 6879 | var index = pasteDetails.cells[0].column; |
||
| 6880 | var context = rows[pasteDetails.cells[0].row]; |
||
| 6881 | var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context); |
||
| 6882 | var mergedGrid = insertCols(index, grid, gridB, pasteDetails.generators, comparator); |
||
| 637 | daniel-mar | 6883 | return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column); |
| 597 | daniel-mar | 6884 | }; |
| 6885 | var opPasteColsAfter = function (grid, pasteDetails, comparator, _genWrappers) { |
||
| 6886 | var rows = extractGridDetails(grid).rows; |
||
| 6887 | var index = pasteDetails.cells[pasteDetails.cells.length - 1].column + pasteDetails.cells[pasteDetails.cells.length - 1].colspan; |
||
| 6888 | var context = rows[pasteDetails.cells[0].row]; |
||
| 6889 | var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context); |
||
| 6890 | var mergedGrid = insertCols(index, grid, gridB, pasteDetails.generators, comparator); |
||
| 637 | daniel-mar | 6891 | return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column); |
| 597 | daniel-mar | 6892 | }; |
| 6893 | var opPasteRowsBefore = function (grid, pasteDetails, comparator, _genWrappers) { |
||
| 6894 | var rows = extractGridDetails(grid).rows; |
||
| 6895 | var index = pasteDetails.cells[0].row; |
||
| 6896 | var context = rows[index]; |
||
| 6897 | var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context); |
||
| 6898 | var mergedGrid = insertRows(index, grid, gridB, pasteDetails.generators, comparator); |
||
| 637 | daniel-mar | 6899 | return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column); |
| 597 | daniel-mar | 6900 | }; |
| 6901 | var opPasteRowsAfter = function (grid, pasteDetails, comparator, _genWrappers) { |
||
| 6902 | var rows = extractGridDetails(grid).rows; |
||
| 6903 | var index = pasteDetails.cells[pasteDetails.cells.length - 1].row + pasteDetails.cells[pasteDetails.cells.length - 1].rowspan; |
||
| 6904 | var context = rows[pasteDetails.cells[0].row]; |
||
| 6905 | var gridB = gridifyRows(pasteDetails.clipboard, pasteDetails.generators, context); |
||
| 6906 | var mergedGrid = insertRows(index, grid, gridB, pasteDetails.generators, comparator); |
||
| 637 | daniel-mar | 6907 | return bundle(mergedGrid, pasteDetails.cells[0].row, pasteDetails.cells[0].column); |
| 597 | daniel-mar | 6908 | }; |
| 637 | daniel-mar | 6909 | var opGetColumnsType = function (table, target) { |
| 597 | daniel-mar | 6910 | var house = Warehouse.fromTable(table); |
| 6911 | var details = onCells(house, target); |
||
| 6912 | return details.bind(function (selectedCells) { |
||
| 6913 | var lastSelectedCell = selectedCells[selectedCells.length - 1]; |
||
| 6914 | var minColRange = selectedCells[0].column; |
||
| 6915 | var maxColRange = lastSelectedCell.column + lastSelectedCell.colspan; |
||
| 637 | daniel-mar | 6916 | var selectedColumnCells = flatten$1(map$1(house.all, function (row) { |
| 6917 | return filter$2(row.cells, function (cell) { |
||
| 597 | daniel-mar | 6918 | return cell.column >= minColRange && cell.column < maxColRange; |
| 6919 | }); |
||
| 6920 | })); |
||
| 637 | daniel-mar | 6921 | return findCommonCellType(selectedColumnCells); |
| 597 | daniel-mar | 6922 | }).getOr(''); |
| 6923 | }; |
||
| 637 | daniel-mar | 6924 | var opGetCellsType = function (table, target) { |
| 6925 | var house = Warehouse.fromTable(table); |
||
| 6926 | var details = onCells(house, target); |
||
| 6927 | return details.bind(findCommonCellType).getOr(''); |
||
| 597 | daniel-mar | 6928 | }; |
| 637 | daniel-mar | 6929 | var opGetRowsType = function (table, target) { |
| 6930 | var house = Warehouse.fromTable(table); |
||
| 6931 | var details = onCells(house, target); |
||
| 6932 | return details.bind(function (selectedCells) { |
||
| 6933 | var lastSelectedCell = selectedCells[selectedCells.length - 1]; |
||
| 6934 | var minRowRange = selectedCells[0].row; |
||
| 6935 | var maxRowRange = lastSelectedCell.row + lastSelectedCell.rowspan; |
||
| 6936 | var selectedRows = house.all.slice(minRowRange, maxRowRange); |
||
| 6937 | return findCommonRowType(selectedRows); |
||
| 6938 | }).getOr(''); |
||
| 6939 | }; |
||
| 6940 | var resize = function (table, list, details, behaviours) { |
||
| 6941 | return adjustWidthTo(table, list, details, behaviours.sizing); |
||
| 6942 | }; |
||
| 6943 | var adjustAndRedistributeWidths = function (table, list, details, behaviours) { |
||
| 6944 | return adjustAndRedistributeWidths$1(table, list, details, behaviours.sizing, behaviours.resize); |
||
| 6945 | }; |
||
| 597 | daniel-mar | 6946 | var firstColumnIsLocked = function (_warehouse, details) { |
| 6947 | return exists(details, function (detail) { |
||
| 6948 | return detail.column === 0 && detail.isLocked; |
||
| 6949 | }); |
||
| 6950 | }; |
||
| 6951 | var lastColumnIsLocked = function (warehouse, details) { |
||
| 6952 | return exists(details, function (detail) { |
||
| 6953 | return detail.column + detail.colspan >= warehouse.grid.columns && detail.isLocked; |
||
| 6954 | }); |
||
| 6955 | }; |
||
| 6956 | var getColumnsWidth = function (warehouse, details) { |
||
| 637 | daniel-mar | 6957 | var columns$1 = columns(warehouse); |
| 597 | daniel-mar | 6958 | var uniqueCols = uniqueColumns(details); |
| 6959 | return foldl(uniqueCols, function (acc, detail) { |
||
| 637 | daniel-mar | 6960 | var column = columns$1[detail.column]; |
| 6961 | var colWidth = column.map(getOuter$2).getOr(0); |
||
| 597 | daniel-mar | 6962 | return acc + colWidth; |
| 6963 | }, 0); |
||
| 6964 | }; |
||
| 6965 | var insertColumnsExtractor = function (before) { |
||
| 6966 | return function (warehouse, target) { |
||
| 6967 | return onCells(warehouse, target).filter(function (details) { |
||
| 6968 | var checkLocked = before ? firstColumnIsLocked : lastColumnIsLocked; |
||
| 6969 | return !checkLocked(warehouse, details); |
||
| 6970 | }).map(function (details) { |
||
| 6971 | return { |
||
| 6972 | details: details, |
||
| 6973 | pixelDelta: getColumnsWidth(warehouse, details) |
||
| 6974 | }; |
||
| 6975 | }); |
||
| 6976 | }; |
||
| 6977 | }; |
||
| 6978 | var eraseColumnsExtractor = function (warehouse, target) { |
||
| 6979 | return onUnlockedCells(warehouse, target).map(function (details) { |
||
| 6980 | return { |
||
| 6981 | details: details, |
||
| 6982 | pixelDelta: -getColumnsWidth(warehouse, details) |
||
| 6983 | }; |
||
| 6984 | }); |
||
| 6985 | }; |
||
| 6986 | var pasteColumnsExtractor = function (before) { |
||
| 6987 | return function (warehouse, target) { |
||
| 6988 | return onPasteByEditor(warehouse, target).filter(function (details) { |
||
| 6989 | var checkLocked = before ? firstColumnIsLocked : lastColumnIsLocked; |
||
| 6990 | return !checkLocked(warehouse, details.cells); |
||
| 6991 | }); |
||
| 6992 | }; |
||
| 6993 | }; |
||
| 679 | daniel-mar | 6994 | var headerCellGenerator = Generators.transform('th'); |
| 6995 | var bodyCellGenerator = Generators.transform('td'); |
||
| 597 | daniel-mar | 6996 | var insertRowsBefore = run(opInsertRowsBefore, onCells, noop, noop, Generators.modification); |
| 6997 | var insertRowsAfter = run(opInsertRowsAfter, onCells, noop, noop, Generators.modification); |
||
| 637 | daniel-mar | 6998 | var insertColumnsBefore = run(opInsertColumnsBefore, insertColumnsExtractor(true), adjustAndRedistributeWidths, noop, Generators.modification); |
| 6999 | var insertColumnsAfter = run(opInsertColumnsAfter, insertColumnsExtractor(false), adjustAndRedistributeWidths, noop, Generators.modification); |
||
| 7000 | var eraseColumns = run(opEraseColumns, eraseColumnsExtractor, adjustAndRedistributeWidths, prune, Generators.modification); |
||
| 597 | daniel-mar | 7001 | var eraseRows = run(opEraseRows, onCells, noop, prune, Generators.modification); |
| 679 | daniel-mar | 7002 | var makeColumnsHeader = run(opMakeColumnsHeader, onUnlockedCells, noop, noop, headerCellGenerator); |
| 7003 | var unmakeColumnsHeader = run(opUnmakeColumnsHeader, onUnlockedCells, noop, noop, bodyCellGenerator); |
||
| 7004 | var makeRowsHeader = run(opMakeRowsHeader, onUnlockedCells, noop, noop, headerCellGenerator); |
||
| 7005 | var makeRowsBody = run(opMakeRowsBody, onUnlockedCells, noop, noop, bodyCellGenerator); |
||
| 7006 | var makeRowsFooter = run(opMakeRowsFooter, onUnlockedCells, noop, noop, bodyCellGenerator); |
||
| 7007 | var makeCellsHeader = run(opMakeCellsHeader, onUnlockedCells, noop, noop, headerCellGenerator); |
||
| 7008 | var unmakeCellsHeader = run(opUnmakeCellsHeader, onUnlockedCells, noop, noop, bodyCellGenerator); |
||
| 597 | daniel-mar | 7009 | var mergeCells = run(opMergeCells, onUnlockedMergable, resize, noop, Generators.merging); |
| 7010 | var unmergeCells = run(opUnmergeCells, onUnlockedUnmergable, resize, noop, Generators.merging); |
||
| 7011 | var pasteCells = run(opPasteCells, onPaste, resize, noop, Generators.modification); |
||
| 7012 | var pasteColsBefore = run(opPasteColsBefore, pasteColumnsExtractor(true), noop, noop, Generators.modification); |
||
| 7013 | var pasteColsAfter = run(opPasteColsAfter, pasteColumnsExtractor(false), noop, noop, Generators.modification); |
||
| 7014 | var pasteRowsBefore = run(opPasteRowsBefore, onPasteByEditor, noop, noop, Generators.modification); |
||
| 7015 | var pasteRowsAfter = run(opPasteRowsAfter, onPasteByEditor, noop, noop, Generators.modification); |
||
| 637 | daniel-mar | 7016 | var getColumnsType = opGetColumnsType; |
| 7017 | var getCellsType = opGetCellsType; |
||
| 7018 | var getRowsType = opGetRowsType; |
||
| 597 | daniel-mar | 7019 | |
| 637 | daniel-mar | 7020 | var TableActions = function (editor, cellSelection, lazyWire) { |
| 597 | daniel-mar | 7021 | var isTableBody = function (editor) { |
| 637 | daniel-mar | 7022 | return name(getBody(editor)) === 'table'; |
| 597 | daniel-mar | 7023 | }; |
| 7024 | var lastRowGuard = function (table) { |
||
| 7025 | return isTableBody(editor) === false || getGridSize(table).rows > 1; |
||
| 7026 | }; |
||
| 7027 | var lastColumnGuard = function (table) { |
||
| 7028 | return isTableBody(editor) === false || getGridSize(table).columns > 1; |
||
| 7029 | }; |
||
| 7030 | var cloneFormats = getCloneElements(editor); |
||
| 7031 | var colMutationOp = isResizeTableColumnResizing(editor) ? noop : halve; |
||
| 637 | daniel-mar | 7032 | var getTableSectionType = function (table) { |
| 7033 | switch (getTableHeaderType(editor)) { |
||
| 7034 | case 'section': |
||
| 7035 | return TableSection.section(); |
||
| 7036 | case 'sectionCells': |
||
| 7037 | return TableSection.sectionCells(); |
||
| 7038 | case 'cells': |
||
| 7039 | return TableSection.cells(); |
||
| 7040 | default: |
||
| 7041 | return TableSection.getTableSectionType(table, 'section'); |
||
| 7042 | } |
||
| 7043 | }; |
||
| 7044 | var setSelectionFromAction = function (table, result) { |
||
| 7045 | return result.cursor.fold(function () { |
||
| 7046 | var cells = cells$1(table); |
||
| 7047 | return head(cells).filter(inBody).map(function (firstCell) { |
||
| 7048 | cellSelection.clear(table); |
||
| 7049 | var rng = editor.dom.createRng(); |
||
| 7050 | rng.selectNode(firstCell.dom); |
||
| 7051 | editor.selection.setRng(rng); |
||
| 7052 | set$2(firstCell, 'data-mce-selected', '1'); |
||
| 7053 | return rng; |
||
| 7054 | }); |
||
| 7055 | }, function (cell) { |
||
| 7056 | var des = freefallRtl(cell); |
||
| 7057 | var rng = editor.dom.createRng(); |
||
| 7058 | rng.setStart(des.element.dom, des.offset); |
||
| 7059 | rng.setEnd(des.element.dom, des.offset); |
||
| 7060 | editor.selection.setRng(rng); |
||
| 7061 | cellSelection.clear(table); |
||
| 7062 | return Optional.some(rng); |
||
| 7063 | }); |
||
| 7064 | }; |
||
| 597 | daniel-mar | 7065 | var execute = function (operation, guard, mutate, lazyWire, effect) { |
| 637 | daniel-mar | 7066 | return function (table, target, noEvents) { |
| 7067 | if (noEvents === void 0) { |
||
| 7068 | noEvents = false; |
||
| 7069 | } |
||
| 597 | daniel-mar | 7070 | removeDataStyle(table); |
| 7071 | var wire = lazyWire(); |
||
| 7072 | var doc = SugarElement.fromDom(editor.getDoc()); |
||
| 7073 | var generators = cellOperations(mutate, doc, cloneFormats); |
||
| 637 | daniel-mar | 7074 | var behaviours = { |
| 7075 | sizing: get$4(editor, table), |
||
| 7076 | resize: isResizeTableColumnResizing(editor) ? resizeTable() : preserveTable(), |
||
| 7077 | section: getTableSectionType(table) |
||
| 7078 | }; |
||
| 7079 | return guard(table) ? operation(wire, table, target, generators, behaviours).bind(function (result) { |
||
| 7080 | each$2(result.newRows, function (row) { |
||
| 597 | daniel-mar | 7081 | fireNewRow(editor, row.dom); |
| 7082 | }); |
||
| 637 | daniel-mar | 7083 | each$2(result.newCells, function (cell) { |
| 597 | daniel-mar | 7084 | fireNewCell(editor, cell.dom); |
| 7085 | }); |
||
| 637 | daniel-mar | 7086 | var range = setSelectionFromAction(table, result); |
| 7087 | if (inBody(table)) { |
||
| 7088 | removeDataStyle(table); |
||
| 7089 | if (!noEvents) { |
||
| 7090 | fireTableModified(editor, table.dom, effect); |
||
| 7091 | } |
||
| 7092 | } |
||
| 7093 | return range.map(function (rng) { |
||
| 597 | daniel-mar | 7094 | return { |
| 7095 | rng: rng, |
||
| 7096 | effect: effect |
||
| 7097 | }; |
||
| 7098 | }); |
||
| 7099 | }) : Optional.none(); |
||
| 7100 | }; |
||
| 7101 | }; |
||
| 7102 | var deleteRow = execute(eraseRows, lastRowGuard, noop, lazyWire, structureModified); |
||
| 7103 | var deleteColumn = execute(eraseColumns, lastColumnGuard, noop, lazyWire, structureModified); |
||
| 7104 | var insertRowsBefore$1 = execute(insertRowsBefore, always, noop, lazyWire, structureModified); |
||
| 7105 | var insertRowsAfter$1 = execute(insertRowsAfter, always, noop, lazyWire, structureModified); |
||
| 7106 | var insertColumnsBefore$1 = execute(insertColumnsBefore, always, colMutationOp, lazyWire, structureModified); |
||
| 7107 | var insertColumnsAfter$1 = execute(insertColumnsAfter, always, colMutationOp, lazyWire, structureModified); |
||
| 7108 | var mergeCells$1 = execute(mergeCells, always, noop, lazyWire, structureModified); |
||
| 7109 | var unmergeCells$1 = execute(unmergeCells, always, noop, lazyWire, structureModified); |
||
| 7110 | var pasteColsBefore$1 = execute(pasteColsBefore, always, noop, lazyWire, structureModified); |
||
| 7111 | var pasteColsAfter$1 = execute(pasteColsAfter, always, noop, lazyWire, structureModified); |
||
| 7112 | var pasteRowsBefore$1 = execute(pasteRowsBefore, always, noop, lazyWire, structureModified); |
||
| 7113 | var pasteRowsAfter$1 = execute(pasteRowsAfter, always, noop, lazyWire, structureModified); |
||
| 637 | daniel-mar | 7114 | var pasteCells$1 = execute(pasteCells, always, noop, lazyWire, styleAndStructureModified); |
| 7115 | var makeCellsHeader$1 = execute(makeCellsHeader, always, noop, lazyWire, structureModified); |
||
| 7116 | var unmakeCellsHeader$1 = execute(unmakeCellsHeader, always, noop, lazyWire, structureModified); |
||
| 597 | daniel-mar | 7117 | var makeColumnsHeader$1 = execute(makeColumnsHeader, always, noop, lazyWire, structureModified); |
| 7118 | var unmakeColumnsHeader$1 = execute(unmakeColumnsHeader, always, noop, lazyWire, structureModified); |
||
| 637 | daniel-mar | 7119 | var makeRowsHeader$1 = execute(makeRowsHeader, always, noop, lazyWire, structureModified); |
| 7120 | var makeRowsBody$1 = execute(makeRowsBody, always, noop, lazyWire, structureModified); |
||
| 7121 | var makeRowsFooter$1 = execute(makeRowsFooter, always, noop, lazyWire, structureModified); |
||
| 7122 | var getTableCellType = getCellsType; |
||
| 7123 | var getTableColType = getColumnsType; |
||
| 7124 | var getTableRowType = getRowsType; |
||
| 597 | daniel-mar | 7125 | return { |
| 7126 | deleteRow: deleteRow, |
||
| 7127 | deleteColumn: deleteColumn, |
||
| 7128 | insertRowsBefore: insertRowsBefore$1, |
||
| 7129 | insertRowsAfter: insertRowsAfter$1, |
||
| 7130 | insertColumnsBefore: insertColumnsBefore$1, |
||
| 7131 | insertColumnsAfter: insertColumnsAfter$1, |
||
| 7132 | mergeCells: mergeCells$1, |
||
| 7133 | unmergeCells: unmergeCells$1, |
||
| 7134 | pasteColsBefore: pasteColsBefore$1, |
||
| 7135 | pasteColsAfter: pasteColsAfter$1, |
||
| 7136 | pasteRowsBefore: pasteRowsBefore$1, |
||
| 7137 | pasteRowsAfter: pasteRowsAfter$1, |
||
| 7138 | pasteCells: pasteCells$1, |
||
| 637 | daniel-mar | 7139 | makeCellsHeader: makeCellsHeader$1, |
| 7140 | unmakeCellsHeader: unmakeCellsHeader$1, |
||
| 597 | daniel-mar | 7141 | makeColumnsHeader: makeColumnsHeader$1, |
| 7142 | unmakeColumnsHeader: unmakeColumnsHeader$1, |
||
| 637 | daniel-mar | 7143 | makeRowsHeader: makeRowsHeader$1, |
| 7144 | makeRowsBody: makeRowsBody$1, |
||
| 7145 | makeRowsFooter: makeRowsFooter$1, |
||
| 597 | daniel-mar | 7146 | getTableRowType: getTableRowType, |
| 7147 | getTableCellType: getTableCellType, |
||
| 7148 | getTableColType: getTableColType |
||
| 7149 | }; |
||
| 7150 | }; |
||
| 7151 | |||
| 7152 | var DefaultRenderOptions = { |
||
| 7153 | styles: { |
||
| 7154 | 'border-collapse': 'collapse', |
||
| 7155 | 'width': '100%' |
||
| 7156 | }, |
||
| 7157 | attributes: { border: '1' }, |
||
| 7158 | colGroups: false |
||
| 7159 | }; |
||
| 7160 | var tableHeaderCell = function () { |
||
| 7161 | return SugarElement.fromTag('th'); |
||
| 7162 | }; |
||
| 7163 | var tableCell = function () { |
||
| 7164 | return SugarElement.fromTag('td'); |
||
| 7165 | }; |
||
| 7166 | var tableColumn = function () { |
||
| 7167 | return SugarElement.fromTag('col'); |
||
| 7168 | }; |
||
| 7169 | var createRow = function (columns, rowHeaders, columnHeaders, rowIndex) { |
||
| 7170 | var tr = SugarElement.fromTag('tr'); |
||
| 7171 | for (var j = 0; j < columns; j++) { |
||
| 7172 | var td = rowIndex < rowHeaders || j < columnHeaders ? tableHeaderCell() : tableCell(); |
||
| 7173 | if (j < columnHeaders) { |
||
| 637 | daniel-mar | 7174 | set$2(td, 'scope', 'row'); |
| 597 | daniel-mar | 7175 | } |
| 7176 | if (rowIndex < rowHeaders) { |
||
| 637 | daniel-mar | 7177 | set$2(td, 'scope', 'col'); |
| 597 | daniel-mar | 7178 | } |
| 637 | daniel-mar | 7179 | append$1(td, SugarElement.fromTag('br')); |
| 7180 | append$1(tr, td); |
||
| 597 | daniel-mar | 7181 | } |
| 7182 | return tr; |
||
| 7183 | }; |
||
| 7184 | var createGroupRow = function (columns) { |
||
| 7185 | var columnGroup = SugarElement.fromTag('colgroup'); |
||
| 637 | daniel-mar | 7186 | range$1(columns, function () { |
| 7187 | return append$1(columnGroup, tableColumn()); |
||
| 597 | daniel-mar | 7188 | }); |
| 7189 | return columnGroup; |
||
| 7190 | }; |
||
| 7191 | var createRows = function (rows, columns, rowHeaders, columnHeaders) { |
||
| 637 | daniel-mar | 7192 | return range$1(rows, function (r) { |
| 597 | daniel-mar | 7193 | return createRow(columns, rowHeaders, columnHeaders, r); |
| 7194 | }); |
||
| 7195 | }; |
||
| 637 | daniel-mar | 7196 | var render = function (rows, columns, rowHeaders, columnHeaders, headerType, renderOpts) { |
| 597 | daniel-mar | 7197 | if (renderOpts === void 0) { |
| 7198 | renderOpts = DefaultRenderOptions; |
||
| 7199 | } |
||
| 7200 | var table = SugarElement.fromTag('table'); |
||
| 7201 | var rowHeadersGoInThead = headerType !== 'cells'; |
||
| 637 | daniel-mar | 7202 | setAll(table, renderOpts.styles); |
| 7203 | setAll$1(table, renderOpts.attributes); |
||
| 597 | daniel-mar | 7204 | if (renderOpts.colGroups) { |
| 637 | daniel-mar | 7205 | append$1(table, createGroupRow(columns)); |
| 597 | daniel-mar | 7206 | } |
| 7207 | var actualRowHeaders = Math.min(rows, rowHeaders); |
||
| 7208 | if (rowHeadersGoInThead && rowHeaders > 0) { |
||
| 7209 | var thead = SugarElement.fromTag('thead'); |
||
| 637 | daniel-mar | 7210 | append$1(table, thead); |
| 597 | daniel-mar | 7211 | var theadRowHeaders = headerType === 'sectionCells' ? actualRowHeaders : 0; |
| 7212 | var theadRows = createRows(rowHeaders, columns, theadRowHeaders, columnHeaders); |
||
| 637 | daniel-mar | 7213 | append(thead, theadRows); |
| 597 | daniel-mar | 7214 | } |
| 7215 | var tbody = SugarElement.fromTag('tbody'); |
||
| 637 | daniel-mar | 7216 | append$1(table, tbody); |
| 597 | daniel-mar | 7217 | var numRows = rowHeadersGoInThead ? rows - actualRowHeaders : rows; |
| 7218 | var numRowHeaders = rowHeadersGoInThead ? 0 : rowHeaders; |
||
| 7219 | var tbodyRows = createRows(numRows, columns, numRowHeaders, columnHeaders); |
||
| 637 | daniel-mar | 7220 | append(tbody, tbodyRows); |
| 597 | daniel-mar | 7221 | return table; |
| 7222 | }; |
||
| 7223 | |||
| 637 | daniel-mar | 7224 | var get$2 = function (element) { |
| 597 | daniel-mar | 7225 | return element.dom.innerHTML; |
| 7226 | }; |
||
| 637 | daniel-mar | 7227 | var getOuter = function (element) { |
| 597 | daniel-mar | 7228 | var container = SugarElement.fromTag('div'); |
| 7229 | var clone = SugarElement.fromDom(element.dom.cloneNode(true)); |
||
| 637 | daniel-mar | 7230 | append$1(container, clone); |
| 7231 | return get$2(container); |
||
| 597 | daniel-mar | 7232 | }; |
| 7233 | |||
| 7234 | var placeCaretInCell = function (editor, cell) { |
||
| 7235 | editor.selection.select(cell.dom, true); |
||
| 7236 | editor.selection.collapse(true); |
||
| 7237 | }; |
||
| 7238 | var selectFirstCellInTable = function (editor, tableElm) { |
||
| 637 | daniel-mar | 7239 | descendant(tableElm, 'td,th').each(curry(placeCaretInCell, editor)); |
| 597 | daniel-mar | 7240 | }; |
| 7241 | var fireEvents = function (editor, table) { |
||
| 637 | daniel-mar | 7242 | each$2(descendants(table, 'tr'), function (row) { |
| 597 | daniel-mar | 7243 | fireNewRow(editor, row.dom); |
| 637 | daniel-mar | 7244 | each$2(descendants(row, 'th,td'), function (cell) { |
| 597 | daniel-mar | 7245 | fireNewCell(editor, cell.dom); |
| 7246 | }); |
||
| 7247 | }); |
||
| 7248 | }; |
||
| 637 | daniel-mar | 7249 | var isPercentage = function (width) { |
| 597 | daniel-mar | 7250 | return isString(width) && width.indexOf('%') !== -1; |
| 7251 | }; |
||
| 637 | daniel-mar | 7252 | var insert = function (editor, columns, rows, colHeaders, rowHeaders) { |
| 597 | daniel-mar | 7253 | var defaultStyles = getDefaultStyles(editor); |
| 7254 | var options = { |
||
| 7255 | styles: defaultStyles, |
||
| 7256 | attributes: getDefaultAttributes(editor), |
||
| 7257 | colGroups: useColumnGroup(editor) |
||
| 7258 | }; |
||
| 7259 | editor.undoManager.ignore(function () { |
||
| 637 | daniel-mar | 7260 | var table = render(rows, columns, rowHeaders, colHeaders, getTableHeaderType(editor), options); |
| 7261 | set$2(table, 'data-mce-id', '__mce'); |
||
| 7262 | var html = getOuter(table); |
||
| 597 | daniel-mar | 7263 | editor.insertContent(html); |
| 7264 | editor.addVisual(); |
||
| 7265 | }); |
||
| 637 | daniel-mar | 7266 | return descendant(getBody(editor), 'table[data-mce-id="__mce"]').map(function (table) { |
| 597 | daniel-mar | 7267 | if (isPixelsForced(editor)) { |
| 679 | daniel-mar | 7268 | enforcePixels(table); |
| 597 | daniel-mar | 7269 | } else if (isResponsiveForced(editor)) { |
| 7270 | enforceNone(table); |
||
| 637 | daniel-mar | 7271 | } else if (isPercentagesForced(editor) || isPercentage(defaultStyles.width)) { |
| 679 | daniel-mar | 7272 | enforcePercentage(table); |
| 597 | daniel-mar | 7273 | } |
| 7274 | removeDataStyle(table); |
||
| 637 | daniel-mar | 7275 | remove$7(table, 'data-mce-id'); |
| 597 | daniel-mar | 7276 | fireEvents(editor, table); |
| 7277 | selectFirstCellInTable(editor, table); |
||
| 7278 | return table.dom; |
||
| 7279 | }).getOr(null); |
||
| 7280 | }; |
||
| 7281 | var insertTableWithDataValidation = function (editor, rows, columns, options, errorMsg) { |
||
| 7282 | if (options === void 0) { |
||
| 7283 | options = {}; |
||
| 7284 | } |
||
| 7285 | var checkInput = function (val) { |
||
| 7286 | return isNumber(val) && val > 0; |
||
| 7287 | }; |
||
| 7288 | if (checkInput(rows) && checkInput(columns)) { |
||
| 7289 | var headerRows = options.headerRows || 0; |
||
| 7290 | var headerColumns = options.headerColumns || 0; |
||
| 637 | daniel-mar | 7291 | return insert(editor, columns, rows, headerColumns, headerRows); |
| 597 | daniel-mar | 7292 | } else { |
| 7293 | console.error(errorMsg); |
||
| 7294 | return null; |
||
| 7295 | } |
||
| 7296 | }; |
||
| 7297 | |||
| 7298 | var getClipboardElements = function (getClipboard) { |
||
| 7299 | return function () { |
||
| 7300 | return getClipboard().fold(function () { |
||
| 7301 | return []; |
||
| 7302 | }, function (elems) { |
||
| 637 | daniel-mar | 7303 | return map$1(elems, function (e) { |
| 597 | daniel-mar | 7304 | return e.dom; |
| 7305 | }); |
||
| 7306 | }); |
||
| 7307 | }; |
||
| 7308 | }; |
||
| 7309 | var setClipboardElements = function (setClipboard) { |
||
| 7310 | return function (elems) { |
||
| 637 | daniel-mar | 7311 | var elmsOpt = elems.length > 0 ? Optional.some(fromDom(elems)) : Optional.none(); |
| 597 | daniel-mar | 7312 | setClipboard(elmsOpt); |
| 7313 | }; |
||
| 7314 | }; |
||
| 7315 | var insertTable = function (editor) { |
||
| 7316 | return function (columns, rows, options) { |
||
| 7317 | if (options === void 0) { |
||
| 7318 | options = {}; |
||
| 7319 | } |
||
| 7320 | var table = insertTableWithDataValidation(editor, rows, columns, options, 'Invalid values for insertTable - rows and columns values are required to insert a table.'); |
||
| 7321 | editor.undoManager.add(); |
||
| 7322 | return table; |
||
| 7323 | }; |
||
| 7324 | }; |
||
| 7325 | var getApi = function (editor, clipboard, resizeHandler, selectionTargets) { |
||
| 7326 | return { |
||
| 7327 | insertTable: insertTable(editor), |
||
| 7328 | setClipboardRows: setClipboardElements(clipboard.setRows), |
||
| 7329 | getClipboardRows: getClipboardElements(clipboard.getRows), |
||
| 7330 | setClipboardCols: setClipboardElements(clipboard.setColumns), |
||
| 7331 | getClipboardCols: getClipboardElements(clipboard.getColumns), |
||
| 7332 | resizeHandler: resizeHandler, |
||
| 7333 | selectionTargets: selectionTargets |
||
| 7334 | }; |
||
| 7335 | }; |
||
| 7336 | |||
| 7337 | var constrainSpan = function (element, property, value) { |
||
| 7338 | var currentColspan = getAttrValue(element, property, 1); |
||
| 7339 | if (value === 1 || currentColspan <= 1) { |
||
| 637 | daniel-mar | 7340 | remove$7(element, property); |
| 597 | daniel-mar | 7341 | } else { |
| 637 | daniel-mar | 7342 | set$2(element, property, Math.min(value, currentColspan)); |
| 597 | daniel-mar | 7343 | } |
| 7344 | }; |
||
| 7345 | var generateColGroup = function (house, minColRange, maxColRange) { |
||
| 7346 | if (Warehouse.hasColumns(house)) { |
||
| 637 | daniel-mar | 7347 | var colsToCopy = filter$2(Warehouse.justColumns(house), function (col) { |
| 597 | daniel-mar | 7348 | return col.column >= minColRange && col.column < maxColRange; |
| 7349 | }); |
||
| 637 | daniel-mar | 7350 | var copiedCols = map$1(colsToCopy, function (c) { |
| 597 | daniel-mar | 7351 | var clonedCol = deep(c.element); |
| 7352 | constrainSpan(clonedCol, 'span', maxColRange - minColRange); |
||
| 7353 | return clonedCol; |
||
| 7354 | }); |
||
| 7355 | var fakeColgroup = SugarElement.fromTag('colgroup'); |
||
| 637 | daniel-mar | 7356 | append(fakeColgroup, copiedCols); |
| 597 | daniel-mar | 7357 | return [fakeColgroup]; |
| 7358 | } else { |
||
| 7359 | return []; |
||
| 7360 | } |
||
| 7361 | }; |
||
| 7362 | var generateRows = function (house, minColRange, maxColRange) { |
||
| 637 | daniel-mar | 7363 | return map$1(house.all, function (row) { |
| 7364 | var cellsToCopy = filter$2(row.cells, function (cell) { |
||
| 597 | daniel-mar | 7365 | return cell.column >= minColRange && cell.column < maxColRange; |
| 7366 | }); |
||
| 637 | daniel-mar | 7367 | var copiedCells = map$1(cellsToCopy, function (cell) { |
| 597 | daniel-mar | 7368 | var clonedCell = deep(cell.element); |
| 7369 | constrainSpan(clonedCell, 'colspan', maxColRange - minColRange); |
||
| 7370 | return clonedCell; |
||
| 7371 | }); |
||
| 7372 | var fakeTR = SugarElement.fromTag('tr'); |
||
| 637 | daniel-mar | 7373 | append(fakeTR, copiedCells); |
| 597 | daniel-mar | 7374 | return fakeTR; |
| 7375 | }); |
||
| 7376 | }; |
||
| 7377 | var copyCols = function (table, target) { |
||
| 7378 | var house = Warehouse.fromTable(table); |
||
| 7379 | var details = onUnlockedCells(house, target); |
||
| 7380 | return details.map(function (selectedCells) { |
||
| 7381 | var lastSelectedCell = selectedCells[selectedCells.length - 1]; |
||
| 7382 | var minColRange = selectedCells[0].column; |
||
| 7383 | var maxColRange = lastSelectedCell.column + lastSelectedCell.colspan; |
||
| 7384 | var fakeColGroups = generateColGroup(house, minColRange, maxColRange); |
||
| 7385 | var fakeRows = generateRows(house, minColRange, maxColRange); |
||
| 679 | daniel-mar | 7386 | return __spreadArray(__spreadArray([], fakeColGroups, true), fakeRows, true); |
| 597 | daniel-mar | 7387 | }); |
| 7388 | }; |
||
| 7389 | |||
| 7390 | var copyRows = function (table, target, generators) { |
||
| 7391 | var warehouse = Warehouse.fromTable(table); |
||
| 7392 | var details = onCells(warehouse, target); |
||
| 7393 | return details.bind(function (selectedCells) { |
||
| 7394 | var grid = toGrid(warehouse, generators, false); |
||
| 7395 | var rows = extractGridDetails(grid).rows; |
||
| 7396 | var slicedGrid = rows.slice(selectedCells[0].row, selectedCells[selectedCells.length - 1].row + selectedCells[selectedCells.length - 1].rowspan); |
||
| 637 | daniel-mar | 7397 | var filteredGrid = bind$2(slicedGrid, function (row) { |
| 7398 | var newCells = filter$2(row.cells, function (cell) { |
||
| 597 | daniel-mar | 7399 | return !cell.isLocked; |
| 7400 | }); |
||
| 7401 | return newCells.length > 0 ? [__assign(__assign({}, row), { cells: newCells })] : []; |
||
| 7402 | }); |
||
| 637 | daniel-mar | 7403 | var slicedDetails = toDetailList(filteredGrid); |
| 597 | daniel-mar | 7404 | return someIf(slicedDetails.length > 0, slicedDetails); |
| 7405 | }).map(function (slicedDetails) { |
||
| 637 | daniel-mar | 7406 | return copy(slicedDetails); |
| 597 | daniel-mar | 7407 | }); |
| 7408 | }; |
||
| 7409 | |||
| 637 | daniel-mar | 7410 | var global$2 = tinymce.util.Tools.resolve('tinymce.util.Tools'); |
| 597 | daniel-mar | 7411 | |
| 7412 | var getTDTHOverallStyle = function (dom, elm, name) { |
||
| 7413 | var cells = dom.select('td,th', elm); |
||
| 7414 | var firstChildStyle; |
||
| 7415 | var checkChildren = function (firstChildStyle, elms) { |
||
| 7416 | for (var i = 0; i < elms.length; i++) { |
||
| 7417 | var currentStyle = dom.getStyle(elms[i], name); |
||
| 7418 | if (typeof firstChildStyle === 'undefined') { |
||
| 7419 | firstChildStyle = currentStyle; |
||
| 7420 | } |
||
| 7421 | if (firstChildStyle !== currentStyle) { |
||
| 7422 | return ''; |
||
| 7423 | } |
||
| 7424 | } |
||
| 7425 | return firstChildStyle; |
||
| 7426 | }; |
||
| 7427 | return checkChildren(firstChildStyle, cells); |
||
| 7428 | }; |
||
| 7429 | var applyAlign = function (editor, elm, name) { |
||
| 7430 | if (name) { |
||
| 7431 | editor.formatter.apply('align' + name, {}, elm); |
||
| 7432 | } |
||
| 7433 | }; |
||
| 7434 | var applyVAlign = function (editor, elm, name) { |
||
| 7435 | if (name) { |
||
| 7436 | editor.formatter.apply('valign' + name, {}, elm); |
||
| 7437 | } |
||
| 7438 | }; |
||
| 7439 | var unApplyAlign = function (editor, elm) { |
||
| 637 | daniel-mar | 7440 | global$2.each('left center right'.split(' '), function (name) { |
| 597 | daniel-mar | 7441 | editor.formatter.remove('align' + name, {}, elm); |
| 7442 | }); |
||
| 7443 | }; |
||
| 7444 | var unApplyVAlign = function (editor, elm) { |
||
| 637 | daniel-mar | 7445 | global$2.each('top middle bottom'.split(' '), function (name) { |
| 597 | daniel-mar | 7446 | editor.formatter.remove('valign' + name, {}, elm); |
| 7447 | }); |
||
| 7448 | }; |
||
| 7449 | |||
| 637 | daniel-mar | 7450 | var verticalAlignValues = [ |
| 7451 | { |
||
| 7452 | text: 'None', |
||
| 7453 | value: '' |
||
| 7454 | }, |
||
| 7455 | { |
||
| 7456 | text: 'Top', |
||
| 7457 | value: 'top' |
||
| 7458 | }, |
||
| 7459 | { |
||
| 7460 | text: 'Middle', |
||
| 7461 | value: 'middle' |
||
| 7462 | }, |
||
| 7463 | { |
||
| 7464 | text: 'Bottom', |
||
| 7465 | value: 'bottom' |
||
| 7466 | } |
||
| 7467 | ]; |
||
| 7468 | |||
| 7469 | var hexColour = function (value) { |
||
| 7470 | return { value: value }; |
||
| 597 | daniel-mar | 7471 | }; |
| 637 | daniel-mar | 7472 | var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i; |
| 7473 | var longformRegex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i; |
||
| 7474 | var isHexString = function (hex) { |
||
| 7475 | return shorthandRegex.test(hex) || longformRegex.test(hex); |
||
| 597 | daniel-mar | 7476 | }; |
| 637 | daniel-mar | 7477 | var normalizeHex = function (hex) { |
| 7478 | return removeLeading(hex, '#').toUpperCase(); |
||
| 597 | daniel-mar | 7479 | }; |
| 637 | daniel-mar | 7480 | var fromString$1 = function (hex) { |
| 7481 | return isHexString(hex) ? Optional.some({ value: normalizeHex(hex) }) : Optional.none(); |
||
| 7482 | }; |
||
| 7483 | var toHex = function (component) { |
||
| 7484 | var hex = component.toString(16); |
||
| 7485 | return (hex.length === 1 ? '0' + hex : hex).toUpperCase(); |
||
| 7486 | }; |
||
| 7487 | var fromRgba = function (rgbaColour) { |
||
| 7488 | var value = toHex(rgbaColour.red) + toHex(rgbaColour.green) + toHex(rgbaColour.blue); |
||
| 7489 | return hexColour(value); |
||
| 7490 | }; |
||
| 7491 | |||
| 7492 | var rgbRegex = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)/; |
||
| 7493 | var rgbaRegex = /^rgba\((\d+),\s*(\d+),\s*(\d+),\s*(\d?(?:\.\d+)?)\)/; |
||
| 7494 | var rgbaColour = function (red, green, blue, alpha) { |
||
| 597 | daniel-mar | 7495 | return { |
| 637 | daniel-mar | 7496 | red: red, |
| 7497 | green: green, |
||
| 7498 | blue: blue, |
||
| 7499 | alpha: alpha |
||
| 597 | daniel-mar | 7500 | }; |
| 7501 | }; |
||
| 637 | daniel-mar | 7502 | var fromStringValues = function (red, green, blue, alpha) { |
| 7503 | var r = parseInt(red, 10); |
||
| 7504 | var g = parseInt(green, 10); |
||
| 7505 | var b = parseInt(blue, 10); |
||
| 7506 | var a = parseFloat(alpha); |
||
| 7507 | return rgbaColour(r, g, b, a); |
||
| 7508 | }; |
||
| 7509 | var fromString = function (rgbaString) { |
||
| 7510 | if (rgbaString === 'transparent') { |
||
| 7511 | return Optional.some(rgbaColour(0, 0, 0, 0)); |
||
| 7512 | } |
||
| 7513 | var rgbMatch = rgbRegex.exec(rgbaString); |
||
| 7514 | if (rgbMatch !== null) { |
||
| 7515 | return Optional.some(fromStringValues(rgbMatch[1], rgbMatch[2], rgbMatch[3], '1')); |
||
| 7516 | } |
||
| 7517 | var rgbaMatch = rgbaRegex.exec(rgbaString); |
||
| 7518 | if (rgbaMatch !== null) { |
||
| 7519 | return Optional.some(fromStringValues(rgbaMatch[1], rgbaMatch[2], rgbaMatch[3], rgbaMatch[4])); |
||
| 7520 | } |
||
| 7521 | return Optional.none(); |
||
| 7522 | }; |
||
| 7523 | |||
| 7524 | var anyToHex = function (color) { |
||
| 7525 | return fromString$1(color).orThunk(function () { |
||
| 7526 | return fromString(color).map(fromRgba); |
||
| 7527 | }).getOrThunk(function () { |
||
| 7528 | var canvas = document.createElement('canvas'); |
||
| 7529 | canvas.height = 1; |
||
| 7530 | canvas.width = 1; |
||
| 7531 | var canvasContext = canvas.getContext('2d'); |
||
| 7532 | canvasContext.clearRect(0, 0, canvas.width, canvas.height); |
||
| 7533 | canvasContext.fillStyle = '#FFFFFF'; |
||
| 7534 | canvasContext.fillStyle = color; |
||
| 7535 | canvasContext.fillRect(0, 0, 1, 1); |
||
| 7536 | var rgba = canvasContext.getImageData(0, 0, 1, 1).data; |
||
| 7537 | var r = rgba[0]; |
||
| 7538 | var g = rgba[1]; |
||
| 7539 | var b = rgba[2]; |
||
| 7540 | var a = rgba[3]; |
||
| 7541 | return fromRgba(rgbaColour(r, g, b, a)); |
||
| 597 | daniel-mar | 7542 | }); |
| 7543 | }; |
||
| 637 | daniel-mar | 7544 | |
| 679 | daniel-mar | 7545 | var Cell = function (initial) { |
| 7546 | var value = initial; |
||
| 7547 | var get = function () { |
||
| 7548 | return value; |
||
| 7549 | }; |
||
| 7550 | var set = function (v) { |
||
| 7551 | value = v; |
||
| 7552 | }; |
||
| 7553 | return { |
||
| 7554 | get: get, |
||
| 7555 | set: set |
||
| 7556 | }; |
||
| 7557 | }; |
||
| 7558 | |||
| 637 | daniel-mar | 7559 | var singleton = function (doRevoke) { |
| 7560 | var subject = Cell(Optional.none()); |
||
| 7561 | var revoke = function () { |
||
| 7562 | return subject.get().each(doRevoke); |
||
| 597 | daniel-mar | 7563 | }; |
| 637 | daniel-mar | 7564 | var clear = function () { |
| 7565 | revoke(); |
||
| 7566 | subject.set(Optional.none()); |
||
| 7567 | }; |
||
| 7568 | var isSet = function () { |
||
| 7569 | return subject.get().isSome(); |
||
| 7570 | }; |
||
| 7571 | var get = function () { |
||
| 7572 | return subject.get(); |
||
| 7573 | }; |
||
| 7574 | var set = function (s) { |
||
| 7575 | revoke(); |
||
| 7576 | subject.set(Optional.some(s)); |
||
| 7577 | }; |
||
| 597 | daniel-mar | 7578 | return { |
| 637 | daniel-mar | 7579 | clear: clear, |
| 7580 | isSet: isSet, |
||
| 7581 | get: get, |
||
| 7582 | set: set |
||
| 597 | daniel-mar | 7583 | }; |
| 7584 | }; |
||
| 637 | daniel-mar | 7585 | var unbindable = function () { |
| 7586 | return singleton(function (s) { |
||
| 7587 | return s.unbind(); |
||
| 7588 | }); |
||
| 597 | daniel-mar | 7589 | }; |
| 637 | daniel-mar | 7590 | var value = function () { |
| 7591 | var subject = singleton(noop); |
||
| 7592 | var on = function (f) { |
||
| 7593 | return subject.get().each(f); |
||
| 7594 | }; |
||
| 7595 | return __assign(__assign({}, subject), { on: on }); |
||
| 7596 | }; |
||
| 7597 | |||
| 7598 | var onSetupToggle = function (editor, selections, formatName, formatValue) { |
||
| 7599 | return function (api) { |
||
| 7600 | var boundCallback = unbindable(); |
||
| 7601 | var isNone = isEmpty$1(formatValue); |
||
| 7602 | var init = function () { |
||
| 7603 | var selectedCells = getCellsFromSelection(selections); |
||
| 7604 | var checkNode = function (cell) { |
||
| 7605 | return editor.formatter.match(formatName, { value: formatValue }, cell.dom, isNone); |
||
| 7606 | }; |
||
| 7607 | if (isNone) { |
||
| 7608 | api.setActive(!exists(selectedCells, checkNode)); |
||
| 7609 | boundCallback.set(editor.formatter.formatChanged(formatName, function (match) { |
||
| 7610 | return api.setActive(!match); |
||
| 7611 | }, true)); |
||
| 7612 | } else { |
||
| 7613 | api.setActive(forall(selectedCells, checkNode)); |
||
| 7614 | boundCallback.set(editor.formatter.formatChanged(formatName, api.setActive, false, { value: formatValue })); |
||
| 7615 | } |
||
| 597 | daniel-mar | 7616 | }; |
| 637 | daniel-mar | 7617 | editor.initialized ? init() : editor.on('init', init); |
| 7618 | return boundCallback.clear; |
||
| 597 | daniel-mar | 7619 | }; |
| 637 | daniel-mar | 7620 | }; |
| 7621 | var isListGroup = function (item) { |
||
| 7622 | return hasNonNullableKey(item, 'menu'); |
||
| 7623 | }; |
||
| 7624 | var buildListItems = function (items) { |
||
| 7625 | return map$1(items, function (item) { |
||
| 7626 | var text = item.text || item.title; |
||
| 7627 | if (isListGroup(item)) { |
||
| 7628 | return { |
||
| 7629 | text: text, |
||
| 7630 | items: buildListItems(item.menu) |
||
| 7631 | }; |
||
| 7632 | } else { |
||
| 7633 | return { |
||
| 7634 | text: text, |
||
| 7635 | value: item.value |
||
| 7636 | }; |
||
| 597 | daniel-mar | 7637 | } |
| 637 | daniel-mar | 7638 | }); |
| 7639 | }; |
||
| 7640 | var buildMenuItems = function (editor, selections, items, format, onAction) { |
||
| 7641 | return map$1(items, function (item) { |
||
| 7642 | var text = item.text || item.title; |
||
| 7643 | if (isListGroup(item)) { |
||
| 7644 | return { |
||
| 7645 | type: 'nestedmenuitem', |
||
| 7646 | text: text, |
||
| 7647 | getSubmenuItems: function () { |
||
| 7648 | return buildMenuItems(editor, selections, item.menu, format, onAction); |
||
| 7649 | } |
||
| 7650 | }; |
||
| 7651 | } else { |
||
| 7652 | return { |
||
| 7653 | text: text, |
||
| 7654 | type: 'togglemenuitem', |
||
| 7655 | onAction: function () { |
||
| 7656 | return onAction(item.value); |
||
| 7657 | }, |
||
| 7658 | onSetup: onSetupToggle(editor, selections, format, item.value) |
||
| 7659 | }; |
||
| 7660 | } |
||
| 7661 | }); |
||
| 7662 | }; |
||
| 7663 | var applyTableCellStyle = function (editor, style) { |
||
| 7664 | return function (value) { |
||
| 7665 | var _a; |
||
| 7666 | editor.execCommand('mceTableApplyCellStyle', false, (_a = {}, _a[style] = value, _a)); |
||
| 597 | daniel-mar | 7667 | }; |
| 7668 | }; |
||
| 637 | daniel-mar | 7669 | var filterNoneItem = function (list) { |
| 7670 | return bind$2(list, function (item) { |
||
| 7671 | if (isListGroup(item)) { |
||
| 7672 | return [__assign(__assign({}, item), { menu: filterNoneItem(item.menu) })]; |
||
| 7673 | } else { |
||
| 7674 | return isNotEmpty(item.value) ? [item] : []; |
||
| 597 | daniel-mar | 7675 | } |
| 637 | daniel-mar | 7676 | }); |
| 7677 | }; |
||
| 7678 | var generateMenuItemsCallback = function (editor, selections, items, format, onAction) { |
||
| 7679 | return function (callback) { |
||
| 7680 | return callback(buildMenuItems(editor, selections, items, format, onAction)); |
||
| 597 | daniel-mar | 7681 | }; |
| 7682 | }; |
||
| 637 | daniel-mar | 7683 | var buildColorMenu = function (editor, colorList, style) { |
| 7684 | var colorMap = map$1(colorList, function (entry) { |
||
| 7685 | return { |
||
| 7686 | text: entry.title, |
||
| 7687 | value: '#' + anyToHex(entry.value).value, |
||
| 7688 | type: 'choiceitem' |
||
| 7689 | }; |
||
| 7690 | }); |
||
| 7691 | return [{ |
||
| 7692 | type: 'fancymenuitem', |
||
| 7693 | fancytype: 'colorswatch', |
||
| 7694 | initData: { |
||
| 7695 | colors: colorMap.length > 0 ? colorMap : undefined, |
||
| 7696 | allowCustomColors: false |
||
| 7697 | }, |
||
| 7698 | onAction: function (data) { |
||
| 7699 | var _a; |
||
| 7700 | var value = data.value === 'remove' ? '' : data.value; |
||
| 7701 | editor.execCommand('mceTableApplyCellStyle', false, (_a = {}, _a[style] = value, _a)); |
||
| 7702 | } |
||
| 7703 | }]; |
||
| 597 | daniel-mar | 7704 | }; |
| 637 | daniel-mar | 7705 | var changeRowHeader = function (editor) { |
| 7706 | return function () { |
||
| 7707 | var currentType = editor.queryCommandValue('mceTableRowType'); |
||
| 7708 | var newType = currentType === 'header' ? 'body' : 'header'; |
||
| 7709 | editor.execCommand('mceTableRowType', false, { type: newType }); |
||
| 597 | daniel-mar | 7710 | }; |
| 7711 | }; |
||
| 637 | daniel-mar | 7712 | var changeColumnHeader = function (editor) { |
| 7713 | return function () { |
||
| 7714 | var currentType = editor.queryCommandValue('mceTableColType'); |
||
| 7715 | var newType = currentType === 'th' ? 'td' : 'th'; |
||
| 7716 | editor.execCommand('mceTableColType', false, { type: newType }); |
||
| 7717 | }; |
||
| 7718 | }; |
||
| 597 | daniel-mar | 7719 | |
| 637 | daniel-mar | 7720 | var getClassList$1 = function (editor) { |
| 597 | daniel-mar | 7721 | var classes = buildListItems(getCellClassList(editor)); |
| 7722 | if (classes.length > 0) { |
||
| 7723 | return Optional.some({ |
||
| 7724 | name: 'class', |
||
| 7725 | type: 'listbox', |
||
| 7726 | label: 'Class', |
||
| 7727 | items: classes |
||
| 7728 | }); |
||
| 7729 | } |
||
| 7730 | return Optional.none(); |
||
| 7731 | }; |
||
| 637 | daniel-mar | 7732 | var children = [ |
| 597 | daniel-mar | 7733 | { |
| 7734 | name: 'width', |
||
| 7735 | type: 'input', |
||
| 7736 | label: 'Width' |
||
| 7737 | }, |
||
| 7738 | { |
||
| 7739 | name: 'height', |
||
| 7740 | type: 'input', |
||
| 7741 | label: 'Height' |
||
| 7742 | }, |
||
| 7743 | { |
||
| 7744 | name: 'celltype', |
||
| 7745 | type: 'listbox', |
||
| 7746 | label: 'Cell type', |
||
| 7747 | items: [ |
||
| 7748 | { |
||
| 7749 | text: 'Cell', |
||
| 7750 | value: 'td' |
||
| 7751 | }, |
||
| 7752 | { |
||
| 7753 | text: 'Header cell', |
||
| 7754 | value: 'th' |
||
| 7755 | } |
||
| 7756 | ] |
||
| 7757 | }, |
||
| 7758 | { |
||
| 7759 | name: 'scope', |
||
| 7760 | type: 'listbox', |
||
| 7761 | label: 'Scope', |
||
| 7762 | items: [ |
||
| 7763 | { |
||
| 7764 | text: 'None', |
||
| 7765 | value: '' |
||
| 7766 | }, |
||
| 7767 | { |
||
| 7768 | text: 'Row', |
||
| 7769 | value: 'row' |
||
| 7770 | }, |
||
| 7771 | { |
||
| 7772 | text: 'Column', |
||
| 7773 | value: 'col' |
||
| 7774 | }, |
||
| 7775 | { |
||
| 7776 | text: 'Row group', |
||
| 7777 | value: 'rowgroup' |
||
| 7778 | }, |
||
| 7779 | { |
||
| 7780 | text: 'Column group', |
||
| 7781 | value: 'colgroup' |
||
| 7782 | } |
||
| 7783 | ] |
||
| 7784 | }, |
||
| 7785 | { |
||
| 7786 | name: 'halign', |
||
| 7787 | type: 'listbox', |
||
| 7788 | label: 'Horizontal align', |
||
| 7789 | items: [ |
||
| 7790 | { |
||
| 7791 | text: 'None', |
||
| 7792 | value: '' |
||
| 7793 | }, |
||
| 7794 | { |
||
| 7795 | text: 'Left', |
||
| 7796 | value: 'left' |
||
| 7797 | }, |
||
| 7798 | { |
||
| 7799 | text: 'Center', |
||
| 7800 | value: 'center' |
||
| 7801 | }, |
||
| 7802 | { |
||
| 7803 | text: 'Right', |
||
| 7804 | value: 'right' |
||
| 7805 | } |
||
| 7806 | ] |
||
| 7807 | }, |
||
| 7808 | { |
||
| 7809 | name: 'valign', |
||
| 7810 | type: 'listbox', |
||
| 7811 | label: 'Vertical align', |
||
| 637 | daniel-mar | 7812 | items: verticalAlignValues |
| 597 | daniel-mar | 7813 | } |
| 7814 | ]; |
||
| 637 | daniel-mar | 7815 | var getItems$2 = function (editor) { |
| 7816 | return children.concat(getClassList$1(editor).toArray()); |
||
| 597 | daniel-mar | 7817 | }; |
| 7818 | |||
| 637 | daniel-mar | 7819 | var getAdvancedTab = function (editor, dialogName) { |
| 7820 | var emptyBorderStyle = [{ |
||
| 7821 | text: 'Select...', |
||
| 7822 | value: '' |
||
| 7823 | }]; |
||
| 7824 | var advTabItems = [ |
||
| 7825 | { |
||
| 7826 | name: 'borderstyle', |
||
| 7827 | type: 'listbox', |
||
| 7828 | label: 'Border style', |
||
| 7829 | items: emptyBorderStyle.concat(buildListItems(getTableBorderStyles(editor))) |
||
| 7830 | }, |
||
| 7831 | { |
||
| 7832 | name: 'bordercolor', |
||
| 7833 | type: 'colorinput', |
||
| 7834 | label: 'Border color' |
||
| 7835 | }, |
||
| 7836 | { |
||
| 7837 | name: 'backgroundcolor', |
||
| 7838 | type: 'colorinput', |
||
| 7839 | label: 'Background color' |
||
| 7840 | } |
||
| 7841 | ]; |
||
| 7842 | var borderWidth = { |
||
| 7843 | name: 'borderwidth', |
||
| 7844 | type: 'input', |
||
| 7845 | label: 'Border width' |
||
| 7846 | }; |
||
| 7847 | var items = dialogName === 'cell' ? [borderWidth].concat(advTabItems) : advTabItems; |
||
| 7848 | return { |
||
| 7849 | title: 'Advanced', |
||
| 7850 | name: 'advanced', |
||
| 7851 | items: items |
||
| 7852 | }; |
||
| 7853 | }; |
||
| 7854 | |||
| 597 | daniel-mar | 7855 | var modifiers = function (testTruthy) { |
| 7856 | return function (editor, node) { |
||
| 7857 | var dom = editor.dom; |
||
| 7858 | var setAttrib = function (attr, value) { |
||
| 7859 | if (!testTruthy || value) { |
||
| 7860 | dom.setAttrib(node, attr, value); |
||
| 7861 | } |
||
| 7862 | }; |
||
| 7863 | var setStyle = function (prop, value) { |
||
| 7864 | if (!testTruthy || value) { |
||
| 7865 | dom.setStyle(node, prop, value); |
||
| 7866 | } |
||
| 7867 | }; |
||
| 7868 | var setFormat = function (formatName, value) { |
||
| 7869 | if (!testTruthy || value) { |
||
| 7870 | if (value === '') { |
||
| 7871 | editor.formatter.remove(formatName, { value: null }, node, true); |
||
| 7872 | } else { |
||
| 7873 | editor.formatter.apply(formatName, { value: value }, node); |
||
| 7874 | } |
||
| 7875 | } |
||
| 7876 | }; |
||
| 7877 | return { |
||
| 7878 | setAttrib: setAttrib, |
||
| 7879 | setStyle: setStyle, |
||
| 7880 | setFormat: setFormat |
||
| 7881 | }; |
||
| 7882 | }; |
||
| 7883 | }; |
||
| 7884 | var DomModifier = { |
||
| 7885 | normal: modifiers(false), |
||
| 7886 | ifTruthy: modifiers(true) |
||
| 7887 | }; |
||
| 7888 | |||
| 637 | daniel-mar | 7889 | var rgbToHex = function (dom) { |
| 7890 | return function (value) { |
||
| 7891 | return startsWith(value, 'rgb') ? dom.toHex(value) : value; |
||
| 7892 | }; |
||
| 7893 | }; |
||
| 7894 | var extractAdvancedStyles = function (dom, elm) { |
||
| 7895 | var element = SugarElement.fromDom(elm); |
||
| 7896 | return { |
||
| 7897 | borderwidth: getRaw$2(element, 'border-width').getOr(''), |
||
| 7898 | borderstyle: getRaw$2(element, 'border-style').getOr(''), |
||
| 7899 | bordercolor: getRaw$2(element, 'border-color').map(rgbToHex(dom)).getOr(''), |
||
| 7900 | backgroundcolor: getRaw$2(element, 'background-color').map(rgbToHex(dom)).getOr('') |
||
| 7901 | }; |
||
| 7902 | }; |
||
| 7903 | var getSharedValues = function (data) { |
||
| 7904 | var baseData = data[0]; |
||
| 7905 | var comparisonData = data.slice(1); |
||
| 7906 | each$2(comparisonData, function (items) { |
||
| 7907 | each$2(keys(baseData), function (key) { |
||
| 7908 | each$1(items, function (itemValue, itemKey) { |
||
| 7909 | var comparisonValue = baseData[key]; |
||
| 7910 | if (comparisonValue !== '' && key === itemKey) { |
||
| 7911 | if (comparisonValue !== itemValue) { |
||
| 7912 | baseData[key] = ''; |
||
| 7913 | } |
||
| 7914 | } |
||
| 597 | daniel-mar | 7915 | }); |
| 7916 | }); |
||
| 637 | daniel-mar | 7917 | }); |
| 7918 | return baseData; |
||
| 7919 | }; |
||
| 7920 | var getAlignment = function (formats, formatName, editor, elm) { |
||
| 7921 | return find$1(formats, function (name) { |
||
| 7922 | return !isUndefined(editor.formatter.matchNode(elm, formatName + name)); |
||
| 7923 | }).getOr(''); |
||
| 7924 | }; |
||
| 7925 | var getHAlignment = curry(getAlignment, [ |
||
| 7926 | 'left', |
||
| 7927 | 'center', |
||
| 7928 | 'right' |
||
| 7929 | ], 'align'); |
||
| 7930 | var getVAlignment = curry(getAlignment, [ |
||
| 7931 | 'top', |
||
| 7932 | 'middle', |
||
| 7933 | 'bottom' |
||
| 7934 | ], 'valign'); |
||
| 7935 | var extractDataFromSettings = function (editor, hasAdvTableTab) { |
||
| 7936 | var style = getDefaultStyles(editor); |
||
| 7937 | var attrs = getDefaultAttributes(editor); |
||
| 7938 | var extractAdvancedStyleData = function (dom) { |
||
| 7939 | return { |
||
| 7940 | borderstyle: get$c(style, 'border-style').getOr(''), |
||
| 7941 | bordercolor: rgbToHex(dom)(get$c(style, 'border-color').getOr('')), |
||
| 7942 | backgroundcolor: rgbToHex(dom)(get$c(style, 'background-color').getOr('')) |
||
| 7943 | }; |
||
| 7944 | }; |
||
| 7945 | var defaultData = { |
||
| 7946 | height: '', |
||
| 7947 | width: '100%', |
||
| 7948 | cellspacing: '', |
||
| 7949 | cellpadding: '', |
||
| 7950 | caption: false, |
||
| 7951 | class: '', |
||
| 7952 | align: '', |
||
| 7953 | border: '' |
||
| 7954 | }; |
||
| 7955 | var getBorder = function () { |
||
| 7956 | var borderWidth = style['border-width']; |
||
| 7957 | if (shouldStyleWithCss(editor) && borderWidth) { |
||
| 7958 | return { border: borderWidth }; |
||
| 7959 | } |
||
| 7960 | return get$c(attrs, 'border').fold(function () { |
||
| 7961 | return {}; |
||
| 7962 | }, function (border) { |
||
| 7963 | return { border: border }; |
||
| 597 | daniel-mar | 7964 | }); |
| 637 | daniel-mar | 7965 | }; |
| 7966 | var advStyle = hasAdvTableTab ? extractAdvancedStyleData(editor.dom) : {}; |
||
| 7967 | var getCellPaddingCellSpacing = function () { |
||
| 7968 | var spacing = get$c(style, 'border-spacing').or(get$c(attrs, 'cellspacing')).fold(function () { |
||
| 7969 | return {}; |
||
| 7970 | }, function (cellspacing) { |
||
| 7971 | return { cellspacing: cellspacing }; |
||
| 7972 | }); |
||
| 7973 | var padding = get$c(style, 'border-padding').or(get$c(attrs, 'cellpadding')).fold(function () { |
||
| 7974 | return {}; |
||
| 7975 | }, function (cellpadding) { |
||
| 7976 | return { cellpadding: cellpadding }; |
||
| 7977 | }); |
||
| 7978 | return __assign(__assign({}, spacing), padding); |
||
| 7979 | }; |
||
| 7980 | var data = __assign(__assign(__assign(__assign(__assign(__assign({}, defaultData), style), attrs), advStyle), getBorder()), getCellPaddingCellSpacing()); |
||
| 7981 | return data; |
||
| 7982 | }; |
||
| 7983 | var getRowType = function (elm) { |
||
| 7984 | return table(SugarElement.fromDom(elm)).map(function (table) { |
||
| 7985 | var target = { selection: fromDom(elm.cells) }; |
||
| 7986 | return getRowsType(table, target); |
||
| 7987 | }).getOr(''); |
||
| 7988 | }; |
||
| 7989 | var extractDataFromTableElement = function (editor, elm, hasAdvTableTab) { |
||
| 7990 | var getBorder = function (dom, elm) { |
||
| 7991 | var optBorderWidth = getRaw$2(SugarElement.fromDom(elm), 'border-width'); |
||
| 7992 | if (shouldStyleWithCss(editor) && optBorderWidth.isSome()) { |
||
| 7993 | return optBorderWidth.getOr(''); |
||
| 7994 | } |
||
| 7995 | return dom.getAttrib(elm, 'border') || getTDTHOverallStyle(editor.dom, elm, 'border-width') || getTDTHOverallStyle(editor.dom, elm, 'border'); |
||
| 7996 | }; |
||
| 7997 | var dom = editor.dom; |
||
| 7998 | var cellspacing = shouldStyleWithCss(editor) ? dom.getStyle(elm, 'border-spacing') || dom.getAttrib(elm, 'cellspacing') : dom.getAttrib(elm, 'cellspacing') || dom.getStyle(elm, 'border-spacing'); |
||
| 7999 | var cellpadding = shouldStyleWithCss(editor) ? getTDTHOverallStyle(dom, elm, 'padding') || dom.getAttrib(elm, 'cellpadding') : dom.getAttrib(elm, 'cellpadding') || getTDTHOverallStyle(dom, elm, 'padding'); |
||
| 8000 | return __assign({ |
||
| 8001 | width: dom.getStyle(elm, 'width') || dom.getAttrib(elm, 'width'), |
||
| 8002 | height: dom.getStyle(elm, 'height') || dom.getAttrib(elm, 'height'), |
||
| 8003 | cellspacing: cellspacing, |
||
| 8004 | cellpadding: cellpadding, |
||
| 8005 | border: getBorder(dom, elm), |
||
| 8006 | caption: !!dom.select('caption', elm)[0], |
||
| 8007 | class: dom.getAttrib(elm, 'class', ''), |
||
| 8008 | align: getHAlignment(editor, elm) |
||
| 8009 | }, hasAdvTableTab ? extractAdvancedStyles(dom, elm) : {}); |
||
| 8010 | }; |
||
| 8011 | var extractDataFromRowElement = function (editor, elm, hasAdvancedRowTab) { |
||
| 8012 | var dom = editor.dom; |
||
| 8013 | return __assign({ |
||
| 8014 | height: dom.getStyle(elm, 'height') || dom.getAttrib(elm, 'height'), |
||
| 8015 | class: dom.getAttrib(elm, 'class', ''), |
||
| 8016 | type: getRowType(elm), |
||
| 8017 | align: getHAlignment(editor, elm) |
||
| 8018 | }, hasAdvancedRowTab ? extractAdvancedStyles(dom, elm) : {}); |
||
| 8019 | }; |
||
| 8020 | var extractDataFromCellElement = function (editor, cell, hasAdvancedCellTab, column) { |
||
| 8021 | var dom = editor.dom; |
||
| 8022 | var colElm = column.getOr(cell); |
||
| 8023 | var getStyle = function (element, style) { |
||
| 8024 | return dom.getStyle(element, style) || dom.getAttrib(element, style); |
||
| 8025 | }; |
||
| 8026 | return __assign({ |
||
| 8027 | width: getStyle(colElm, 'width'), |
||
| 8028 | height: getStyle(cell, 'height'), |
||
| 8029 | scope: dom.getAttrib(cell, 'scope'), |
||
| 8030 | celltype: getNodeName(cell), |
||
| 8031 | class: dom.getAttrib(cell, 'class', ''), |
||
| 8032 | halign: getHAlignment(editor, cell), |
||
| 8033 | valign: getVAlignment(editor, cell) |
||
| 8034 | }, hasAdvancedCellTab ? extractAdvancedStyles(dom, cell) : {}); |
||
| 8035 | }; |
||
| 8036 | |||
| 8037 | var getSelectedCells = function (table, cells) { |
||
| 8038 | var warehouse = Warehouse.fromTable(table); |
||
| 8039 | var allCells = Warehouse.justCells(warehouse); |
||
| 8040 | var filtered = filter$2(allCells, function (cellA) { |
||
| 8041 | return exists(cells, function (cellB) { |
||
| 8042 | return eq$1(cellA.element, cellB); |
||
| 8043 | }); |
||
| 597 | daniel-mar | 8044 | }); |
| 637 | daniel-mar | 8045 | return map$1(filtered, function (cell) { |
| 8046 | return { |
||
| 8047 | element: cell.element.dom, |
||
| 8048 | column: Warehouse.getColumnAt(warehouse, cell.column).map(function (col) { |
||
| 8049 | return col.element.dom; |
||
| 8050 | }) |
||
| 8051 | }; |
||
| 8052 | }); |
||
| 597 | daniel-mar | 8053 | }; |
| 637 | daniel-mar | 8054 | var updateSimpleProps$1 = function (modifier, colModifier, data) { |
| 597 | daniel-mar | 8055 | modifier.setAttrib('scope', data.scope); |
| 8056 | modifier.setAttrib('class', data.class); |
||
| 8057 | modifier.setStyle('height', addPxSuffix(data.height)); |
||
| 8058 | colModifier.setStyle('width', addPxSuffix(data.width)); |
||
| 8059 | }; |
||
| 637 | daniel-mar | 8060 | var updateAdvancedProps$1 = function (modifier, data) { |
| 597 | daniel-mar | 8061 | modifier.setFormat('tablecellbackgroundcolor', data.backgroundcolor); |
| 8062 | modifier.setFormat('tablecellbordercolor', data.bordercolor); |
||
| 8063 | modifier.setFormat('tablecellborderstyle', data.borderstyle); |
||
| 8064 | modifier.setFormat('tablecellborderwidth', addPxSuffix(data.borderwidth)); |
||
| 8065 | }; |
||
| 637 | daniel-mar | 8066 | var applyStyleData$1 = function (editor, cells, data) { |
| 8067 | var isSingleCell = cells.length === 1; |
||
| 8068 | each$2(cells, function (item) { |
||
| 8069 | var cellElm = item.element; |
||
| 8070 | var modifier = isSingleCell ? DomModifier.normal(editor, cellElm) : DomModifier.ifTruthy(editor, cellElm); |
||
| 8071 | var colModifier = item.column.map(function (col) { |
||
| 8072 | return isSingleCell ? DomModifier.normal(editor, col) : DomModifier.ifTruthy(editor, col); |
||
| 8073 | }).getOr(modifier); |
||
| 8074 | updateSimpleProps$1(modifier, colModifier, data); |
||
| 8075 | if (hasAdvancedCellTab(editor)) { |
||
| 8076 | updateAdvancedProps$1(modifier, data); |
||
| 8077 | } |
||
| 8078 | if (isSingleCell) { |
||
| 8079 | unApplyAlign(editor, cellElm); |
||
| 8080 | unApplyVAlign(editor, cellElm); |
||
| 8081 | } |
||
| 8082 | if (data.halign) { |
||
| 8083 | applyAlign(editor, cellElm, data.halign); |
||
| 8084 | } |
||
| 8085 | if (data.valign) { |
||
| 8086 | applyVAlign(editor, cellElm, data.valign); |
||
| 8087 | } |
||
| 8088 | }); |
||
| 8089 | }; |
||
| 8090 | var applyStructureData$1 = function (editor, data) { |
||
| 8091 | editor.execCommand('mceTableCellType', false, { |
||
| 8092 | type: data.celltype, |
||
| 8093 | no_events: true |
||
| 8094 | }); |
||
| 8095 | }; |
||
| 597 | daniel-mar | 8096 | var applyCellData = function (editor, cells, oldData, data) { |
| 8097 | var modifiedData = filter$1(data, function (value, key) { |
||
| 8098 | return oldData[key] !== value; |
||
| 8099 | }); |
||
| 8100 | if (size(modifiedData) > 0 && cells.length >= 1) { |
||
| 637 | daniel-mar | 8101 | table(cells[0]).each(function (table) { |
| 8102 | var selectedCells = getSelectedCells(table, cells); |
||
| 8103 | var styleModified = size(filter$1(modifiedData, function (_value, key) { |
||
| 8104 | return key !== 'scope' && key !== 'celltype'; |
||
| 8105 | })) > 0; |
||
| 8106 | var structureModified = has$1(modifiedData, 'celltype'); |
||
| 8107 | if (styleModified || has$1(modifiedData, 'scope')) { |
||
| 8108 | applyStyleData$1(editor, selectedCells, data); |
||
| 8109 | } |
||
| 8110 | if (structureModified) { |
||
| 8111 | applyStructureData$1(editor, data); |
||
| 8112 | } |
||
| 8113 | fireTableModified(editor, table.dom, { |
||
| 8114 | structure: structureModified, |
||
| 8115 | style: styleModified |
||
| 597 | daniel-mar | 8116 | }); |
| 8117 | }); |
||
| 8118 | } |
||
| 8119 | }; |
||
| 8120 | var onSubmitCellForm = function (editor, cells, oldData, api) { |
||
| 8121 | var data = api.getData(); |
||
| 8122 | api.close(); |
||
| 8123 | editor.undoManager.transact(function () { |
||
| 8124 | applyCellData(editor, cells, oldData, data); |
||
| 8125 | editor.focus(); |
||
| 8126 | }); |
||
| 8127 | }; |
||
| 8128 | var getData = function (editor, cells) { |
||
| 637 | daniel-mar | 8129 | var cellsData = table(cells[0]).map(function (table) { |
| 8130 | return map$1(getSelectedCells(table, cells), function (item) { |
||
| 597 | daniel-mar | 8131 | return extractDataFromCellElement(editor, item.element, hasAdvancedCellTab(editor), item.column); |
| 8132 | }); |
||
| 8133 | }); |
||
| 8134 | return getSharedValues(cellsData.getOrDie()); |
||
| 8135 | }; |
||
| 637 | daniel-mar | 8136 | var open$2 = function (editor, selections) { |
| 8137 | var cells = getCellsFromSelection(selections); |
||
| 597 | daniel-mar | 8138 | if (cells.length === 0) { |
| 8139 | return; |
||
| 8140 | } |
||
| 8141 | var data = getData(editor, cells); |
||
| 8142 | var dialogTabPanel = { |
||
| 8143 | type: 'tabpanel', |
||
| 8144 | tabs: [ |
||
| 8145 | { |
||
| 8146 | title: 'General', |
||
| 8147 | name: 'general', |
||
| 637 | daniel-mar | 8148 | items: getItems$2(editor) |
| 597 | daniel-mar | 8149 | }, |
| 637 | daniel-mar | 8150 | getAdvancedTab(editor, 'cell') |
| 597 | daniel-mar | 8151 | ] |
| 8152 | }; |
||
| 8153 | var dialogPanel = { |
||
| 8154 | type: 'panel', |
||
| 8155 | items: [{ |
||
| 8156 | type: 'grid', |
||
| 8157 | columns: 2, |
||
| 637 | daniel-mar | 8158 | items: getItems$2(editor) |
| 597 | daniel-mar | 8159 | }] |
| 8160 | }; |
||
| 8161 | editor.windowManager.open({ |
||
| 8162 | title: 'Cell Properties', |
||
| 8163 | size: 'normal', |
||
| 8164 | body: hasAdvancedCellTab(editor) ? dialogTabPanel : dialogPanel, |
||
| 8165 | buttons: [ |
||
| 8166 | { |
||
| 8167 | type: 'cancel', |
||
| 8168 | name: 'cancel', |
||
| 8169 | text: 'Cancel' |
||
| 8170 | }, |
||
| 8171 | { |
||
| 8172 | type: 'submit', |
||
| 8173 | name: 'save', |
||
| 8174 | text: 'Save', |
||
| 8175 | primary: true |
||
| 8176 | } |
||
| 8177 | ], |
||
| 8178 | initialData: data, |
||
| 8179 | onSubmit: curry(onSubmitCellForm, editor, cells, data) |
||
| 8180 | }); |
||
| 8181 | }; |
||
| 8182 | |||
| 637 | daniel-mar | 8183 | var getClassList = function (editor) { |
| 597 | daniel-mar | 8184 | var classes = buildListItems(getRowClassList(editor)); |
| 8185 | if (classes.length > 0) { |
||
| 8186 | return Optional.some({ |
||
| 8187 | name: 'class', |
||
| 8188 | type: 'listbox', |
||
| 8189 | label: 'Class', |
||
| 8190 | items: classes |
||
| 8191 | }); |
||
| 8192 | } |
||
| 8193 | return Optional.none(); |
||
| 8194 | }; |
||
| 8195 | var formChildren = [ |
||
| 8196 | { |
||
| 8197 | type: 'listbox', |
||
| 8198 | name: 'type', |
||
| 8199 | label: 'Row type', |
||
| 8200 | items: [ |
||
| 8201 | { |
||
| 8202 | text: 'Header', |
||
| 8203 | value: 'header' |
||
| 8204 | }, |
||
| 8205 | { |
||
| 8206 | text: 'Body', |
||
| 8207 | value: 'body' |
||
| 8208 | }, |
||
| 8209 | { |
||
| 8210 | text: 'Footer', |
||
| 8211 | value: 'footer' |
||
| 8212 | } |
||
| 8213 | ] |
||
| 8214 | }, |
||
| 8215 | { |
||
| 8216 | type: 'listbox', |
||
| 8217 | name: 'align', |
||
| 8218 | label: 'Alignment', |
||
| 8219 | items: [ |
||
| 8220 | { |
||
| 8221 | text: 'None', |
||
| 8222 | value: '' |
||
| 8223 | }, |
||
| 8224 | { |
||
| 8225 | text: 'Left', |
||
| 8226 | value: 'left' |
||
| 8227 | }, |
||
| 8228 | { |
||
| 8229 | text: 'Center', |
||
| 8230 | value: 'center' |
||
| 8231 | }, |
||
| 8232 | { |
||
| 8233 | text: 'Right', |
||
| 8234 | value: 'right' |
||
| 8235 | } |
||
| 8236 | ] |
||
| 8237 | }, |
||
| 8238 | { |
||
| 8239 | label: 'Height', |
||
| 8240 | name: 'height', |
||
| 8241 | type: 'input' |
||
| 8242 | } |
||
| 8243 | ]; |
||
| 8244 | var getItems$1 = function (editor) { |
||
| 637 | daniel-mar | 8245 | return formChildren.concat(getClassList(editor).toArray()); |
| 597 | daniel-mar | 8246 | }; |
| 8247 | |||
| 637 | daniel-mar | 8248 | var updateSimpleProps = function (modifier, data) { |
| 597 | daniel-mar | 8249 | modifier.setAttrib('class', data.class); |
| 8250 | modifier.setStyle('height', addPxSuffix(data.height)); |
||
| 8251 | }; |
||
| 637 | daniel-mar | 8252 | var updateAdvancedProps = function (modifier, data) { |
| 597 | daniel-mar | 8253 | modifier.setStyle('background-color', data.backgroundcolor); |
| 8254 | modifier.setStyle('border-color', data.bordercolor); |
||
| 8255 | modifier.setStyle('border-style', data.borderstyle); |
||
| 8256 | }; |
||
| 637 | daniel-mar | 8257 | var applyStyleData = function (editor, rows, data, oldData) { |
| 8258 | var isSingleRow = rows.length === 1; |
||
| 8259 | each$2(rows, function (rowElm) { |
||
| 8260 | var modifier = isSingleRow ? DomModifier.normal(editor, rowElm) : DomModifier.ifTruthy(editor, rowElm); |
||
| 8261 | updateSimpleProps(modifier, data); |
||
| 8262 | if (hasAdvancedRowTab(editor)) { |
||
| 8263 | updateAdvancedProps(modifier, data); |
||
| 8264 | } |
||
| 8265 | if (data.align !== oldData.align) { |
||
| 8266 | unApplyAlign(editor, rowElm); |
||
| 8267 | applyAlign(editor, rowElm, data.align); |
||
| 8268 | } |
||
| 8269 | }); |
||
| 8270 | }; |
||
| 8271 | var applyStructureData = function (editor, data) { |
||
| 8272 | editor.execCommand('mceTableRowType', false, { |
||
| 8273 | type: data.type, |
||
| 8274 | no_events: true |
||
| 8275 | }); |
||
| 8276 | }; |
||
| 597 | daniel-mar | 8277 | var applyRowData = function (editor, rows, oldData, data) { |
| 8278 | var modifiedData = filter$1(data, function (value, key) { |
||
| 8279 | return oldData[key] !== value; |
||
| 8280 | }); |
||
| 8281 | if (size(modifiedData) > 0) { |
||
| 637 | daniel-mar | 8282 | var typeModified_1 = has$1(modifiedData, 'type'); |
| 597 | daniel-mar | 8283 | var styleModified_1 = typeModified_1 ? size(modifiedData) > 1 : true; |
| 637 | daniel-mar | 8284 | if (styleModified_1) { |
| 8285 | applyStyleData(editor, rows, data, oldData); |
||
| 8286 | } |
||
| 8287 | if (typeModified_1) { |
||
| 8288 | applyStructureData(editor, data); |
||
| 8289 | } |
||
| 597 | daniel-mar | 8290 | table(SugarElement.fromDom(rows[0])).each(function (table) { |
| 8291 | return fireTableModified(editor, table.dom, { |
||
| 8292 | structure: typeModified_1, |
||
| 8293 | style: styleModified_1 |
||
| 8294 | }); |
||
| 8295 | }); |
||
| 8296 | } |
||
| 8297 | }; |
||
| 8298 | var onSubmitRowForm = function (editor, rows, oldData, api) { |
||
| 8299 | var data = api.getData(); |
||
| 8300 | api.close(); |
||
| 8301 | editor.undoManager.transact(function () { |
||
| 8302 | applyRowData(editor, rows, oldData, data); |
||
| 8303 | editor.focus(); |
||
| 8304 | }); |
||
| 8305 | }; |
||
| 8306 | var open$1 = function (editor) { |
||
| 8307 | var rows = getRowsFromSelection(getSelectionStart(editor), ephemera.selected); |
||
| 8308 | if (rows.length === 0) { |
||
| 8309 | return; |
||
| 8310 | } |
||
| 637 | daniel-mar | 8311 | var rowsData = map$1(rows, function (rowElm) { |
| 597 | daniel-mar | 8312 | return extractDataFromRowElement(editor, rowElm.dom, hasAdvancedRowTab(editor)); |
| 8313 | }); |
||
| 8314 | var data = getSharedValues(rowsData); |
||
| 8315 | var dialogTabPanel = { |
||
| 8316 | type: 'tabpanel', |
||
| 8317 | tabs: [ |
||
| 8318 | { |
||
| 8319 | title: 'General', |
||
| 8320 | name: 'general', |
||
| 8321 | items: getItems$1(editor) |
||
| 8322 | }, |
||
| 637 | daniel-mar | 8323 | getAdvancedTab(editor, 'row') |
| 597 | daniel-mar | 8324 | ] |
| 8325 | }; |
||
| 8326 | var dialogPanel = { |
||
| 8327 | type: 'panel', |
||
| 8328 | items: [{ |
||
| 8329 | type: 'grid', |
||
| 8330 | columns: 2, |
||
| 8331 | items: getItems$1(editor) |
||
| 8332 | }] |
||
| 8333 | }; |
||
| 8334 | editor.windowManager.open({ |
||
| 8335 | title: 'Row Properties', |
||
| 8336 | size: 'normal', |
||
| 8337 | body: hasAdvancedRowTab(editor) ? dialogTabPanel : dialogPanel, |
||
| 8338 | buttons: [ |
||
| 8339 | { |
||
| 8340 | type: 'cancel', |
||
| 8341 | name: 'cancel', |
||
| 8342 | text: 'Cancel' |
||
| 8343 | }, |
||
| 8344 | { |
||
| 8345 | type: 'submit', |
||
| 8346 | name: 'save', |
||
| 8347 | text: 'Save', |
||
| 8348 | primary: true |
||
| 8349 | } |
||
| 8350 | ], |
||
| 8351 | initialData: data, |
||
| 637 | daniel-mar | 8352 | onSubmit: curry(onSubmitRowForm, editor, map$1(rows, function (r) { |
| 597 | daniel-mar | 8353 | return r.dom; |
| 8354 | }), data) |
||
| 8355 | }); |
||
| 8356 | }; |
||
| 8357 | |||
| 637 | daniel-mar | 8358 | var getItems = function (editor, classes, insertNewTable) { |
| 597 | daniel-mar | 8359 | var rowColCountItems = !insertNewTable ? [] : [ |
| 8360 | { |
||
| 8361 | type: 'input', |
||
| 8362 | name: 'cols', |
||
| 8363 | label: 'Cols', |
||
| 8364 | inputMode: 'numeric' |
||
| 8365 | }, |
||
| 8366 | { |
||
| 8367 | type: 'input', |
||
| 8368 | name: 'rows', |
||
| 8369 | label: 'Rows', |
||
| 8370 | inputMode: 'numeric' |
||
| 8371 | } |
||
| 8372 | ]; |
||
| 8373 | var alwaysItems = [ |
||
| 8374 | { |
||
| 8375 | type: 'input', |
||
| 8376 | name: 'width', |
||
| 8377 | label: 'Width' |
||
| 8378 | }, |
||
| 8379 | { |
||
| 8380 | type: 'input', |
||
| 8381 | name: 'height', |
||
| 8382 | label: 'Height' |
||
| 8383 | } |
||
| 8384 | ]; |
||
| 8385 | var appearanceItems = hasAppearanceOptions(editor) ? [ |
||
| 8386 | { |
||
| 8387 | type: 'input', |
||
| 8388 | name: 'cellspacing', |
||
| 8389 | label: 'Cell spacing', |
||
| 8390 | inputMode: 'numeric' |
||
| 8391 | }, |
||
| 8392 | { |
||
| 8393 | type: 'input', |
||
| 8394 | name: 'cellpadding', |
||
| 8395 | label: 'Cell padding', |
||
| 8396 | inputMode: 'numeric' |
||
| 8397 | }, |
||
| 8398 | { |
||
| 8399 | type: 'input', |
||
| 8400 | name: 'border', |
||
| 8401 | label: 'Border width' |
||
| 8402 | }, |
||
| 8403 | { |
||
| 8404 | type: 'label', |
||
| 8405 | label: 'Caption', |
||
| 8406 | items: [{ |
||
| 8407 | type: 'checkbox', |
||
| 8408 | name: 'caption', |
||
| 8409 | label: 'Show caption' |
||
| 8410 | }] |
||
| 8411 | } |
||
| 8412 | ] : []; |
||
| 8413 | var alignmentItem = [{ |
||
| 8414 | type: 'listbox', |
||
| 8415 | name: 'align', |
||
| 8416 | label: 'Alignment', |
||
| 8417 | items: [ |
||
| 8418 | { |
||
| 8419 | text: 'None', |
||
| 8420 | value: '' |
||
| 8421 | }, |
||
| 8422 | { |
||
| 8423 | text: 'Left', |
||
| 8424 | value: 'left' |
||
| 8425 | }, |
||
| 8426 | { |
||
| 8427 | text: 'Center', |
||
| 8428 | value: 'center' |
||
| 8429 | }, |
||
| 8430 | { |
||
| 8431 | text: 'Right', |
||
| 8432 | value: 'right' |
||
| 8433 | } |
||
| 8434 | ] |
||
| 8435 | }]; |
||
| 8436 | var classListItem = classes.length > 0 ? [{ |
||
| 8437 | type: 'listbox', |
||
| 8438 | name: 'class', |
||
| 8439 | label: 'Class', |
||
| 8440 | items: classes |
||
| 8441 | }] : []; |
||
| 8442 | return rowColCountItems.concat(alwaysItems).concat(appearanceItems).concat(alignmentItem).concat(classListItem); |
||
| 8443 | }; |
||
| 8444 | |||
| 8445 | var styleTDTH = function (dom, elm, name, value) { |
||
| 8446 | if (elm.tagName === 'TD' || elm.tagName === 'TH') { |
||
| 8447 | if (isString(name)) { |
||
| 8448 | dom.setStyle(elm, name, value); |
||
| 8449 | } else { |
||
| 8450 | dom.setStyle(elm, name); |
||
| 8451 | } |
||
| 8452 | } else { |
||
| 8453 | if (elm.children) { |
||
| 8454 | for (var i = 0; i < elm.children.length; i++) { |
||
| 8455 | styleTDTH(dom, elm.children[i], name, value); |
||
| 8456 | } |
||
| 8457 | } |
||
| 8458 | } |
||
| 8459 | }; |
||
| 8460 | var applyDataToElement = function (editor, tableElm, data) { |
||
| 8461 | var dom = editor.dom; |
||
| 8462 | var attrs = {}; |
||
| 8463 | var styles = {}; |
||
| 8464 | attrs.class = data.class; |
||
| 8465 | styles.height = addPxSuffix(data.height); |
||
| 8466 | if (dom.getAttrib(tableElm, 'width') && !shouldStyleWithCss(editor)) { |
||
| 8467 | attrs.width = removePxSuffix(data.width); |
||
| 8468 | } else { |
||
| 8469 | styles.width = addPxSuffix(data.width); |
||
| 8470 | } |
||
| 8471 | if (shouldStyleWithCss(editor)) { |
||
| 8472 | styles['border-width'] = addPxSuffix(data.border); |
||
| 8473 | styles['border-spacing'] = addPxSuffix(data.cellspacing); |
||
| 8474 | } else { |
||
| 8475 | attrs.border = data.border; |
||
| 8476 | attrs.cellpadding = data.cellpadding; |
||
| 8477 | attrs.cellspacing = data.cellspacing; |
||
| 8478 | } |
||
| 8479 | if (shouldStyleWithCss(editor) && tableElm.children) { |
||
| 8480 | for (var i = 0; i < tableElm.children.length; i++) { |
||
| 8481 | styleTDTH(dom, tableElm.children[i], { |
||
| 8482 | 'border-width': addPxSuffix(data.border), |
||
| 8483 | 'padding': addPxSuffix(data.cellpadding) |
||
| 8484 | }); |
||
| 8485 | if (hasAdvancedTableTab(editor)) { |
||
| 8486 | styleTDTH(dom, tableElm.children[i], { 'border-color': data.bordercolor }); |
||
| 8487 | } |
||
| 8488 | } |
||
| 8489 | } |
||
| 8490 | if (hasAdvancedTableTab(editor)) { |
||
| 8491 | styles['background-color'] = data.backgroundcolor; |
||
| 8492 | styles['border-color'] = data.bordercolor; |
||
| 8493 | styles['border-style'] = data.borderstyle; |
||
| 8494 | } |
||
| 8495 | attrs.style = dom.serializeStyle(__assign(__assign({}, getDefaultStyles(editor)), styles)); |
||
| 8496 | dom.setAttribs(tableElm, __assign(__assign({}, getDefaultAttributes(editor)), attrs)); |
||
| 8497 | }; |
||
| 8498 | var onSubmitTableForm = function (editor, tableElm, oldData, api) { |
||
| 8499 | var dom = editor.dom; |
||
| 8500 | var data = api.getData(); |
||
| 8501 | var modifiedData = filter$1(data, function (value, key) { |
||
| 8502 | return oldData[key] !== value; |
||
| 8503 | }); |
||
| 8504 | api.close(); |
||
| 8505 | if (data.class === '') { |
||
| 8506 | delete data.class; |
||
| 8507 | } |
||
| 8508 | editor.undoManager.transact(function () { |
||
| 8509 | if (!tableElm) { |
||
| 8510 | var cols = parseInt(data.cols, 10) || 1; |
||
| 8511 | var rows = parseInt(data.rows, 10) || 1; |
||
| 637 | daniel-mar | 8512 | tableElm = insert(editor, cols, rows, 0, 0); |
| 597 | daniel-mar | 8513 | } |
| 8514 | if (size(modifiedData) > 0) { |
||
| 8515 | applyDataToElement(editor, tableElm, data); |
||
| 637 | daniel-mar | 8516 | var captionElm = dom.select('caption', tableElm)[0]; |
| 8517 | if (captionElm && !data.caption || !captionElm && data.caption) { |
||
| 8518 | editor.execCommand('mceTableToggleCaption'); |
||
| 597 | daniel-mar | 8519 | } |
| 8520 | if (data.align === '') { |
||
| 8521 | unApplyAlign(editor, tableElm); |
||
| 8522 | } else { |
||
| 8523 | applyAlign(editor, tableElm, data.align); |
||
| 8524 | } |
||
| 8525 | } |
||
| 8526 | editor.focus(); |
||
| 8527 | editor.addVisual(); |
||
| 8528 | if (size(modifiedData) > 0) { |
||
| 637 | daniel-mar | 8529 | var captionModified = has$1(modifiedData, 'caption'); |
| 597 | daniel-mar | 8530 | var styleModified = captionModified ? size(modifiedData) > 1 : true; |
| 8531 | fireTableModified(editor, tableElm, { |
||
| 8532 | structure: captionModified, |
||
| 8533 | style: styleModified |
||
| 8534 | }); |
||
| 8535 | } |
||
| 8536 | }); |
||
| 8537 | }; |
||
| 637 | daniel-mar | 8538 | var open = function (editor, insertNewTable) { |
| 597 | daniel-mar | 8539 | var dom = editor.dom; |
| 8540 | var tableElm; |
||
| 8541 | var data = extractDataFromSettings(editor, hasAdvancedTableTab(editor)); |
||
| 8542 | if (insertNewTable === false) { |
||
| 8543 | tableElm = dom.getParent(editor.selection.getStart(), 'table', editor.getBody()); |
||
| 8544 | if (tableElm) { |
||
| 8545 | data = extractDataFromTableElement(editor, tableElm, hasAdvancedTableTab(editor)); |
||
| 8546 | } else { |
||
| 8547 | if (hasAdvancedTableTab(editor)) { |
||
| 8548 | data.borderstyle = ''; |
||
| 8549 | data.bordercolor = ''; |
||
| 8550 | data.backgroundcolor = ''; |
||
| 8551 | } |
||
| 8552 | } |
||
| 8553 | } else { |
||
| 8554 | data.cols = '1'; |
||
| 8555 | data.rows = '1'; |
||
| 8556 | if (hasAdvancedTableTab(editor)) { |
||
| 8557 | data.borderstyle = ''; |
||
| 8558 | data.bordercolor = ''; |
||
| 8559 | data.backgroundcolor = ''; |
||
| 8560 | } |
||
| 8561 | } |
||
| 8562 | var classes = buildListItems(getTableClassList(editor)); |
||
| 8563 | if (classes.length > 0) { |
||
| 8564 | if (data.class) { |
||
| 8565 | data.class = data.class.replace(/\s*mce\-item\-table\s*/g, ''); |
||
| 8566 | } |
||
| 8567 | } |
||
| 8568 | var generalPanel = { |
||
| 8569 | type: 'grid', |
||
| 8570 | columns: 2, |
||
| 637 | daniel-mar | 8571 | items: getItems(editor, classes, insertNewTable) |
| 597 | daniel-mar | 8572 | }; |
| 8573 | var nonAdvancedForm = function () { |
||
| 8574 | return { |
||
| 8575 | type: 'panel', |
||
| 8576 | items: [generalPanel] |
||
| 8577 | }; |
||
| 8578 | }; |
||
| 8579 | var advancedForm = function () { |
||
| 8580 | return { |
||
| 8581 | type: 'tabpanel', |
||
| 8582 | tabs: [ |
||
| 8583 | { |
||
| 8584 | title: 'General', |
||
| 8585 | name: 'general', |
||
| 8586 | items: [generalPanel] |
||
| 8587 | }, |
||
| 637 | daniel-mar | 8588 | getAdvancedTab(editor, 'table') |
| 597 | daniel-mar | 8589 | ] |
| 8590 | }; |
||
| 8591 | }; |
||
| 8592 | var dialogBody = hasAdvancedTableTab(editor) ? advancedForm() : nonAdvancedForm(); |
||
| 8593 | editor.windowManager.open({ |
||
| 8594 | title: 'Table Properties', |
||
| 8595 | size: 'normal', |
||
| 8596 | body: dialogBody, |
||
| 8597 | onSubmit: curry(onSubmitTableForm, editor, tableElm, data), |
||
| 8598 | buttons: [ |
||
| 8599 | { |
||
| 8600 | type: 'cancel', |
||
| 8601 | name: 'cancel', |
||
| 8602 | text: 'Cancel' |
||
| 8603 | }, |
||
| 8604 | { |
||
| 8605 | type: 'submit', |
||
| 8606 | name: 'save', |
||
| 8607 | text: 'Save', |
||
| 8608 | primary: true |
||
| 8609 | } |
||
| 8610 | ], |
||
| 8611 | initialData: data |
||
| 8612 | }); |
||
| 8613 | }; |
||
| 8614 | |||
| 637 | daniel-mar | 8615 | var getSelectionStartCellOrCaption = function (editor) { |
| 8616 | return getSelectionCellOrCaption(getSelectionStart(editor), getIsRoot(editor)); |
||
| 597 | daniel-mar | 8617 | }; |
| 637 | daniel-mar | 8618 | var getSelectionStartCell = function (editor) { |
| 8619 | return getSelectionCell(getSelectionStart(editor), getIsRoot(editor)); |
||
| 597 | daniel-mar | 8620 | }; |
| 8621 | var registerCommands = function (editor, actions, cellSelection, selections, clipboard) { |
||
| 8622 | var isRoot = getIsRoot(editor); |
||
| 8623 | var eraseTable = function () { |
||
| 637 | daniel-mar | 8624 | return getSelectionStartCellOrCaption(editor).each(function (cellOrCaption) { |
| 597 | daniel-mar | 8625 | table(cellOrCaption, isRoot).filter(not(isRoot)).each(function (table) { |
| 8626 | var cursor = SugarElement.fromText(''); |
||
| 637 | daniel-mar | 8627 | after$5(table, cursor); |
| 8628 | remove$5(table); |
||
| 597 | daniel-mar | 8629 | if (editor.dom.isEmpty(editor.getBody())) { |
| 8630 | editor.setContent(''); |
||
| 8631 | editor.selection.setCursorLocation(); |
||
| 8632 | } else { |
||
| 8633 | var rng = editor.dom.createRng(); |
||
| 8634 | rng.setStart(cursor.dom, 0); |
||
| 8635 | rng.setEnd(cursor.dom, 0); |
||
| 8636 | editor.selection.setRng(rng); |
||
| 8637 | editor.nodeChanged(); |
||
| 8638 | } |
||
| 8639 | }); |
||
| 8640 | }); |
||
| 8641 | }; |
||
| 8642 | var setSizingMode = function (sizing) { |
||
| 637 | daniel-mar | 8643 | return getSelectionStartCellOrCaption(editor).each(function (cellOrCaption) { |
| 597 | daniel-mar | 8644 | var isForcedSizing = isResponsiveForced(editor) || isPixelsForced(editor) || isPercentagesForced(editor); |
| 8645 | if (!isForcedSizing) { |
||
| 8646 | table(cellOrCaption, isRoot).each(function (table) { |
||
| 637 | daniel-mar | 8647 | if (sizing === 'relative' && !isPercentSizing(table)) { |
| 679 | daniel-mar | 8648 | enforcePercentage(table); |
| 637 | daniel-mar | 8649 | } else if (sizing === 'fixed' && !isPixelSizing(table)) { |
| 679 | daniel-mar | 8650 | enforcePixels(table); |
| 637 | daniel-mar | 8651 | } else if (sizing === 'responsive' && !isNoneSizing(table)) { |
| 597 | daniel-mar | 8652 | enforceNone(table); |
| 8653 | } |
||
| 8654 | removeDataStyle(table); |
||
| 8655 | fireTableModified(editor, table.dom, structureModified); |
||
| 8656 | }); |
||
| 8657 | } |
||
| 8658 | }); |
||
| 8659 | }; |
||
| 8660 | var getTableFromCell = function (cell) { |
||
| 8661 | return table(cell, isRoot); |
||
| 8662 | }; |
||
| 637 | daniel-mar | 8663 | var performActionOnSelection = function (action) { |
| 8664 | return getSelectionStartCell(editor).bind(function (cell) { |
||
| 8665 | return getTableFromCell(cell).map(function (table) { |
||
| 8666 | return action(table, cell); |
||
| 8667 | }); |
||
| 8668 | }); |
||
| 597 | daniel-mar | 8669 | }; |
| 637 | daniel-mar | 8670 | var toggleTableClass = function (_ui, clazz) { |
| 8671 | performActionOnSelection(function (table) { |
||
| 8672 | editor.formatter.toggle('tableclass', { value: clazz }, table.dom); |
||
| 8673 | fireTableModified(editor, table.dom, styleModified); |
||
| 8674 | }); |
||
| 8675 | }; |
||
| 8676 | var toggleTableCellClass = function (_ui, clazz) { |
||
| 8677 | performActionOnSelection(function (table) { |
||
| 8678 | var selectedCells = getCellsFromSelection(selections); |
||
| 8679 | var allHaveClass = forall(selectedCells, function (cell) { |
||
| 8680 | return editor.formatter.match('tablecellclass', { value: clazz }, cell.dom); |
||
| 597 | daniel-mar | 8681 | }); |
| 637 | daniel-mar | 8682 | var formatterAction = allHaveClass ? editor.formatter.remove : editor.formatter.apply; |
| 8683 | each$2(selectedCells, function (cell) { |
||
| 8684 | return formatterAction('tablecellclass', { value: clazz }, cell.dom); |
||
| 8685 | }); |
||
| 8686 | fireTableModified(editor, table.dom, styleModified); |
||
| 597 | daniel-mar | 8687 | }); |
| 8688 | }; |
||
| 637 | daniel-mar | 8689 | var toggleCaption = function () { |
| 8690 | getSelectionStartCellOrCaption(editor).each(function (cellOrCaption) { |
||
| 8691 | table(cellOrCaption, isRoot).each(function (table) { |
||
| 8692 | child$1(table, 'caption').fold(function () { |
||
| 8693 | var caption = SugarElement.fromTag('caption'); |
||
| 8694 | append$1(caption, SugarElement.fromText('Caption')); |
||
| 8695 | appendAt(table, caption, 0); |
||
| 8696 | editor.selection.setCursorLocation(caption.dom, 0); |
||
| 8697 | }, function (caption) { |
||
| 8698 | if (isTag('caption')(cellOrCaption)) { |
||
| 8699 | one('td', table).each(function (td) { |
||
| 8700 | return editor.selection.setCursorLocation(td.dom, 0); |
||
| 8701 | }); |
||
| 8702 | } |
||
| 8703 | remove$5(caption); |
||
| 8704 | }); |
||
| 8705 | fireTableModified(editor, table.dom, structureModified); |
||
| 597 | daniel-mar | 8706 | }); |
| 8707 | }); |
||
| 8708 | }; |
||
| 637 | daniel-mar | 8709 | var postExecute = function (_data) { |
| 8710 | editor.focus(); |
||
| 8711 | }; |
||
| 8712 | var actOnSelection = function (execute, noEvents) { |
||
| 8713 | if (noEvents === void 0) { |
||
| 8714 | noEvents = false; |
||
| 8715 | } |
||
| 8716 | return performActionOnSelection(function (table, startCell) { |
||
| 8717 | var targets = forMenu(selections, table, startCell); |
||
| 8718 | execute(table, targets, noEvents).each(postExecute); |
||
| 8719 | }); |
||
| 8720 | }; |
||
| 8721 | var copyRowSelection = function () { |
||
| 8722 | return performActionOnSelection(function (table, startCell) { |
||
| 8723 | var targets = forMenu(selections, table, startCell); |
||
| 8724 | var generators = cellOperations(noop, SugarElement.fromDom(editor.getDoc()), Optional.none()); |
||
| 8725 | return copyRows(table, targets, generators); |
||
| 8726 | }); |
||
| 8727 | }; |
||
| 597 | daniel-mar | 8728 | var copyColSelection = function () { |
| 637 | daniel-mar | 8729 | return performActionOnSelection(function (table, startCell) { |
| 8730 | var targets = forMenu(selections, table, startCell); |
||
| 8731 | return copyCols(table, targets); |
||
| 597 | daniel-mar | 8732 | }); |
| 8733 | }; |
||
| 8734 | var pasteOnSelection = function (execute, getRows) { |
||
| 8735 | return getRows().each(function (rows) { |
||
| 637 | daniel-mar | 8736 | var clonedRows = map$1(rows, function (row) { |
| 597 | daniel-mar | 8737 | return deep(row); |
| 8738 | }); |
||
| 637 | daniel-mar | 8739 | performActionOnSelection(function (table, startCell) { |
| 8740 | var generators = paste$1(SugarElement.fromDom(editor.getDoc())); |
||
| 8741 | var targets = pasteRows(selections, startCell, clonedRows, generators); |
||
| 8742 | execute(table, targets).each(postExecute); |
||
| 597 | daniel-mar | 8743 | }); |
| 8744 | }); |
||
| 8745 | }; |
||
| 637 | daniel-mar | 8746 | var actOnType = function (getAction) { |
| 8747 | return function (_ui, args) { |
||
| 8748 | return get$c(args, 'type').each(function (type) { |
||
| 8749 | actOnSelection(getAction(type), args.no_events); |
||
| 8750 | }); |
||
| 8751 | }; |
||
| 8752 | }; |
||
| 597 | daniel-mar | 8753 | each$1({ |
| 8754 | mceTableSplitCells: function () { |
||
| 8755 | return actOnSelection(actions.unmergeCells); |
||
| 8756 | }, |
||
| 8757 | mceTableMergeCells: function () { |
||
| 8758 | return actOnSelection(actions.mergeCells); |
||
| 8759 | }, |
||
| 8760 | mceTableInsertRowBefore: function () { |
||
| 8761 | return actOnSelection(actions.insertRowsBefore); |
||
| 8762 | }, |
||
| 8763 | mceTableInsertRowAfter: function () { |
||
| 8764 | return actOnSelection(actions.insertRowsAfter); |
||
| 8765 | }, |
||
| 8766 | mceTableInsertColBefore: function () { |
||
| 8767 | return actOnSelection(actions.insertColumnsBefore); |
||
| 8768 | }, |
||
| 8769 | mceTableInsertColAfter: function () { |
||
| 8770 | return actOnSelection(actions.insertColumnsAfter); |
||
| 8771 | }, |
||
| 8772 | mceTableDeleteCol: function () { |
||
| 8773 | return actOnSelection(actions.deleteColumn); |
||
| 8774 | }, |
||
| 8775 | mceTableDeleteRow: function () { |
||
| 8776 | return actOnSelection(actions.deleteRow); |
||
| 8777 | }, |
||
| 637 | daniel-mar | 8778 | mceTableCutCol: function () { |
| 597 | daniel-mar | 8779 | return copyColSelection().each(function (selection) { |
| 8780 | clipboard.setColumns(selection); |
||
| 8781 | actOnSelection(actions.deleteColumn); |
||
| 8782 | }); |
||
| 8783 | }, |
||
| 637 | daniel-mar | 8784 | mceTableCutRow: function () { |
| 597 | daniel-mar | 8785 | return copyRowSelection().each(function (selection) { |
| 8786 | clipboard.setRows(selection); |
||
| 8787 | actOnSelection(actions.deleteRow); |
||
| 8788 | }); |
||
| 8789 | }, |
||
| 637 | daniel-mar | 8790 | mceTableCopyCol: function () { |
| 597 | daniel-mar | 8791 | return copyColSelection().each(function (selection) { |
| 8792 | return clipboard.setColumns(selection); |
||
| 8793 | }); |
||
| 8794 | }, |
||
| 637 | daniel-mar | 8795 | mceTableCopyRow: function () { |
| 597 | daniel-mar | 8796 | return copyRowSelection().each(function (selection) { |
| 8797 | return clipboard.setRows(selection); |
||
| 8798 | }); |
||
| 8799 | }, |
||
| 637 | daniel-mar | 8800 | mceTablePasteColBefore: function () { |
| 597 | daniel-mar | 8801 | return pasteOnSelection(actions.pasteColsBefore, clipboard.getColumns); |
| 8802 | }, |
||
| 637 | daniel-mar | 8803 | mceTablePasteColAfter: function () { |
| 597 | daniel-mar | 8804 | return pasteOnSelection(actions.pasteColsAfter, clipboard.getColumns); |
| 8805 | }, |
||
| 637 | daniel-mar | 8806 | mceTablePasteRowBefore: function () { |
| 597 | daniel-mar | 8807 | return pasteOnSelection(actions.pasteRowsBefore, clipboard.getRows); |
| 8808 | }, |
||
| 637 | daniel-mar | 8809 | mceTablePasteRowAfter: function () { |
| 597 | daniel-mar | 8810 | return pasteOnSelection(actions.pasteRowsAfter, clipboard.getRows); |
| 8811 | }, |
||
| 8812 | mceTableDelete: eraseTable, |
||
| 637 | daniel-mar | 8813 | mceTableCellToggleClass: toggleTableCellClass, |
| 8814 | mceTableToggleClass: toggleTableClass, |
||
| 8815 | mceTableToggleCaption: toggleCaption, |
||
| 8816 | mceTableSizingMode: function (_ui, sizing) { |
||
| 597 | daniel-mar | 8817 | return setSizingMode(sizing); |
| 8818 | }, |
||
| 637 | daniel-mar | 8819 | mceTableCellType: actOnType(function (type) { |
| 8820 | return type === 'th' ? actions.makeCellsHeader : actions.unmakeCellsHeader; |
||
| 8821 | }), |
||
| 8822 | mceTableColType: actOnType(function (type) { |
||
| 8823 | return type === 'th' ? actions.makeColumnsHeader : actions.unmakeColumnsHeader; |
||
| 8824 | }), |
||
| 8825 | mceTableRowType: actOnType(function (type) { |
||
| 8826 | switch (type) { |
||
| 8827 | case 'header': |
||
| 8828 | return actions.makeRowsHeader; |
||
| 8829 | case 'footer': |
||
| 8830 | return actions.makeRowsFooter; |
||
| 8831 | default: |
||
| 8832 | return actions.makeRowsBody; |
||
| 8833 | } |
||
| 8834 | }) |
||
| 597 | daniel-mar | 8835 | }, function (func, name) { |
| 8836 | return editor.addCommand(name, func); |
||
| 8837 | }); |
||
| 8838 | each$1({ |
||
| 637 | daniel-mar | 8839 | mceTableProps: curry(open, editor, false), |
| 597 | daniel-mar | 8840 | mceTableRowProps: curry(open$1, editor), |
| 637 | daniel-mar | 8841 | mceTableCellProps: curry(open$2, editor, selections) |
| 597 | daniel-mar | 8842 | }, function (func, name) { |
| 8843 | return editor.addCommand(name, function () { |
||
| 8844 | return func(); |
||
| 8845 | }); |
||
| 8846 | }); |
||
| 8847 | editor.addCommand('mceInsertTable', function (_ui, args) { |
||
| 8848 | if (isObject(args) && keys(args).length > 0) { |
||
| 8849 | insertTableWithDataValidation(editor, args.rows, args.columns, args.options, 'Invalid values for mceInsertTable - rows and columns values are required to insert a table.'); |
||
| 8850 | } else { |
||
| 637 | daniel-mar | 8851 | open(editor, true); |
| 597 | daniel-mar | 8852 | } |
| 8853 | }); |
||
| 8854 | editor.addCommand('mceTableApplyCellStyle', function (_ui, args) { |
||
| 8855 | var getFormatName = function (style) { |
||
| 8856 | return 'tablecell' + style.toLowerCase().replace('-', ''); |
||
| 8857 | }; |
||
| 8858 | if (!isObject(args)) { |
||
| 8859 | return; |
||
| 8860 | } |
||
| 637 | daniel-mar | 8861 | var cells = getCellsFromSelection(selections); |
| 597 | daniel-mar | 8862 | if (cells.length === 0) { |
| 8863 | return; |
||
| 8864 | } |
||
| 8865 | var validArgs = filter$1(args, function (value, style) { |
||
| 8866 | return editor.formatter.has(getFormatName(style)) && isString(value); |
||
| 8867 | }); |
||
| 8868 | if (isEmpty(validArgs)) { |
||
| 8869 | return; |
||
| 8870 | } |
||
| 8871 | each$1(validArgs, function (value, style) { |
||
| 637 | daniel-mar | 8872 | each$2(cells, function (cell) { |
| 597 | daniel-mar | 8873 | DomModifier.normal(editor, cell.dom).setFormat(getFormatName(style), value); |
| 8874 | }); |
||
| 8875 | }); |
||
| 8876 | getTableFromCell(cells[0]).each(function (table) { |
||
| 8877 | return fireTableModified(editor, table.dom, styleModified); |
||
| 8878 | }); |
||
| 8879 | }); |
||
| 8880 | }; |
||
| 8881 | |||
| 8882 | var registerQueryCommands = function (editor, actions, selections) { |
||
| 8883 | var isRoot = getIsRoot(editor); |
||
| 637 | daniel-mar | 8884 | var lookupOnSelection = function (action) { |
| 8885 | return getSelectionCell(getSelectionStart(editor)).bind(function (cell) { |
||
| 8886 | return table(cell, isRoot).map(function (table) { |
||
| 8887 | var targets = forMenu(selections, table, cell); |
||
| 8888 | return action(table, targets); |
||
| 8889 | }); |
||
| 8890 | }).getOr(''); |
||
| 597 | daniel-mar | 8891 | }; |
| 8892 | each$1({ |
||
| 8893 | mceTableRowType: function () { |
||
| 637 | daniel-mar | 8894 | return lookupOnSelection(actions.getTableRowType); |
| 597 | daniel-mar | 8895 | }, |
| 8896 | mceTableCellType: function () { |
||
| 637 | daniel-mar | 8897 | return lookupOnSelection(actions.getTableCellType); |
| 597 | daniel-mar | 8898 | }, |
| 8899 | mceTableColType: function () { |
||
| 637 | daniel-mar | 8900 | return lookupOnSelection(actions.getTableColType); |
| 597 | daniel-mar | 8901 | } |
| 8902 | }, function (func, name) { |
||
| 8903 | return editor.addQueryValueHandler(name, func); |
||
| 8904 | }); |
||
| 8905 | }; |
||
| 8906 | |||
| 8907 | var Clipboard = function () { |
||
| 637 | daniel-mar | 8908 | var rows = value(); |
| 8909 | var cols = value(); |
||
| 597 | daniel-mar | 8910 | return { |
| 8911 | getRows: rows.get, |
||
| 8912 | setRows: function (r) { |
||
| 637 | daniel-mar | 8913 | r.fold(rows.clear, rows.set); |
| 8914 | cols.clear(); |
||
| 597 | daniel-mar | 8915 | }, |
| 637 | daniel-mar | 8916 | clearRows: rows.clear, |
| 597 | daniel-mar | 8917 | getColumns: cols.get, |
| 8918 | setColumns: function (c) { |
||
| 637 | daniel-mar | 8919 | c.fold(cols.clear, cols.set); |
| 8920 | rows.clear(); |
||
| 597 | daniel-mar | 8921 | }, |
| 637 | daniel-mar | 8922 | clearColumns: cols.clear |
| 597 | daniel-mar | 8923 | }; |
| 8924 | }; |
||
| 8925 | |||
| 637 | daniel-mar | 8926 | var genericBase = { |
| 8927 | remove_similar: true, |
||
| 8928 | inherit: false |
||
| 8929 | }; |
||
| 8930 | var cellBase = __assign({ selector: 'td,th' }, genericBase); |
||
| 597 | daniel-mar | 8931 | var cellFormats = { |
| 637 | daniel-mar | 8932 | tablecellbackgroundcolor: __assign({ styles: { backgroundColor: '%value' } }, cellBase), |
| 8933 | tablecellverticalalign: __assign({ styles: { 'vertical-align': '%value' } }, cellBase), |
||
| 8934 | tablecellbordercolor: __assign({ styles: { borderColor: '%value' } }, cellBase), |
||
| 8935 | tablecellclass: __assign({ classes: ['%value'] }, cellBase), |
||
| 8936 | tableclass: __assign({ |
||
| 8937 | selector: 'table', |
||
| 8938 | classes: ['%value'] |
||
| 8939 | }, genericBase), |
||
| 8940 | tablecellborderstyle: __assign({ styles: { borderStyle: '%value' } }, cellBase), |
||
| 8941 | tablecellborderwidth: __assign({ styles: { borderWidth: '%value' } }, cellBase) |
||
| 597 | daniel-mar | 8942 | }; |
| 8943 | var registerFormats = function (editor) { |
||
| 8944 | editor.formatter.register(cellFormats); |
||
| 8945 | }; |
||
| 8946 | |||
| 637 | daniel-mar | 8947 | var adt$5 = Adt.generate([ |
| 597 | daniel-mar | 8948 | { none: ['current'] }, |
| 8949 | { first: ['current'] }, |
||
| 8950 | { |
||
| 8951 | middle: [ |
||
| 8952 | 'current', |
||
| 8953 | 'target' |
||
| 8954 | ] |
||
| 8955 | }, |
||
| 8956 | { last: ['current'] } |
||
| 8957 | ]); |
||
| 637 | daniel-mar | 8958 | var none = function (current) { |
| 597 | daniel-mar | 8959 | if (current === void 0) { |
| 8960 | current = undefined; |
||
| 8961 | } |
||
| 637 | daniel-mar | 8962 | return adt$5.none(current); |
| 597 | daniel-mar | 8963 | }; |
| 637 | daniel-mar | 8964 | var CellLocation = __assign(__assign({}, adt$5), { none: none }); |
| 597 | daniel-mar | 8965 | |
| 637 | daniel-mar | 8966 | var walk = function (all, current, index, direction, isEligible) { |
| 8967 | if (isEligible === void 0) { |
||
| 8968 | isEligible = always; |
||
| 8969 | } |
||
| 8970 | var forwards = direction === 1; |
||
| 8971 | if (!forwards && index <= 0) { |
||
| 8972 | return CellLocation.first(all[0]); |
||
| 8973 | } else if (forwards && index >= all.length - 1) { |
||
| 8974 | return CellLocation.last(all[all.length - 1]); |
||
| 8975 | } else { |
||
| 8976 | var newIndex = index + direction; |
||
| 8977 | var elem = all[newIndex]; |
||
| 8978 | return isEligible(elem) ? CellLocation.middle(current, elem) : walk(all, current, newIndex, direction, isEligible); |
||
| 8979 | } |
||
| 8980 | }; |
||
| 8981 | var detect$1 = function (current, isRoot) { |
||
| 597 | daniel-mar | 8982 | return table(current, isRoot).bind(function (table) { |
| 637 | daniel-mar | 8983 | var all = cells$1(table); |
| 597 | daniel-mar | 8984 | var index = findIndex(all, function (x) { |
| 8985 | return eq$1(current, x); |
||
| 8986 | }); |
||
| 8987 | return index.map(function (index) { |
||
| 8988 | return { |
||
| 8989 | index: index, |
||
| 8990 | all: all |
||
| 8991 | }; |
||
| 8992 | }); |
||
| 8993 | }); |
||
| 8994 | }; |
||
| 637 | daniel-mar | 8995 | var next = function (current, isEligible, isRoot) { |
| 8996 | var detection = detect$1(current, isRoot); |
||
| 597 | daniel-mar | 8997 | return detection.fold(function () { |
| 8998 | return CellLocation.none(current); |
||
| 8999 | }, function (info) { |
||
| 637 | daniel-mar | 9000 | return walk(info.all, current, info.index, 1, isEligible); |
| 597 | daniel-mar | 9001 | }); |
| 9002 | }; |
||
| 637 | daniel-mar | 9003 | var prev = function (current, isEligible, isRoot) { |
| 9004 | var detection = detect$1(current, isRoot); |
||
| 597 | daniel-mar | 9005 | return detection.fold(function () { |
| 9006 | return CellLocation.none(); |
||
| 9007 | }, function (info) { |
||
| 637 | daniel-mar | 9008 | return walk(info.all, current, info.index, -1, isEligible); |
| 597 | daniel-mar | 9009 | }); |
| 9010 | }; |
||
| 9011 | |||
| 9012 | var create$2 = function (start, soffset, finish, foffset) { |
||
| 9013 | return { |
||
| 9014 | start: start, |
||
| 9015 | soffset: soffset, |
||
| 9016 | finish: finish, |
||
| 9017 | foffset: foffset |
||
| 9018 | }; |
||
| 9019 | }; |
||
| 9020 | var SimRange = { create: create$2 }; |
||
| 9021 | |||
| 637 | daniel-mar | 9022 | var adt$4 = Adt.generate([ |
| 597 | daniel-mar | 9023 | { before: ['element'] }, |
| 9024 | { |
||
| 9025 | on: [ |
||
| 9026 | 'element', |
||
| 9027 | 'offset' |
||
| 9028 | ] |
||
| 9029 | }, |
||
| 9030 | { after: ['element'] } |
||
| 9031 | ]); |
||
| 9032 | var cata$1 = function (subject, onBefore, onOn, onAfter) { |
||
| 9033 | return subject.fold(onBefore, onOn, onAfter); |
||
| 9034 | }; |
||
| 637 | daniel-mar | 9035 | var getStart$1 = function (situ) { |
| 597 | daniel-mar | 9036 | return situ.fold(identity, identity, identity); |
| 9037 | }; |
||
| 637 | daniel-mar | 9038 | var before$2 = adt$4.before; |
| 9039 | var on = adt$4.on; |
||
| 9040 | var after$3 = adt$4.after; |
||
| 597 | daniel-mar | 9041 | var Situ = { |
| 9042 | before: before$2, |
||
| 9043 | on: on, |
||
| 637 | daniel-mar | 9044 | after: after$3, |
| 597 | daniel-mar | 9045 | cata: cata$1, |
| 637 | daniel-mar | 9046 | getStart: getStart$1 |
| 597 | daniel-mar | 9047 | }; |
| 9048 | |||
| 637 | daniel-mar | 9049 | var adt$3 = Adt.generate([ |
| 597 | daniel-mar | 9050 | { domRange: ['rng'] }, |
| 9051 | { |
||
| 9052 | relative: [ |
||
| 9053 | 'startSitu', |
||
| 9054 | 'finishSitu' |
||
| 9055 | ] |
||
| 9056 | }, |
||
| 9057 | { |
||
| 9058 | exact: [ |
||
| 9059 | 'start', |
||
| 9060 | 'soffset', |
||
| 9061 | 'finish', |
||
| 9062 | 'foffset' |
||
| 9063 | ] |
||
| 9064 | } |
||
| 9065 | ]); |
||
| 9066 | var exactFromRange = function (simRange) { |
||
| 637 | daniel-mar | 9067 | return adt$3.exact(simRange.start, simRange.soffset, simRange.finish, simRange.foffset); |
| 597 | daniel-mar | 9068 | }; |
| 637 | daniel-mar | 9069 | var getStart = function (selection) { |
| 597 | daniel-mar | 9070 | return selection.match({ |
| 9071 | domRange: function (rng) { |
||
| 9072 | return SugarElement.fromDom(rng.startContainer); |
||
| 9073 | }, |
||
| 9074 | relative: function (startSitu, _finishSitu) { |
||
| 9075 | return Situ.getStart(startSitu); |
||
| 9076 | }, |
||
| 9077 | exact: function (start, _soffset, _finish, _foffset) { |
||
| 9078 | return start; |
||
| 9079 | } |
||
| 9080 | }); |
||
| 9081 | }; |
||
| 637 | daniel-mar | 9082 | var domRange = adt$3.domRange; |
| 9083 | var relative = adt$3.relative; |
||
| 9084 | var exact = adt$3.exact; |
||
| 597 | daniel-mar | 9085 | var getWin = function (selection) { |
| 637 | daniel-mar | 9086 | var start = getStart(selection); |
| 597 | daniel-mar | 9087 | return defaultView(start); |
| 9088 | }; |
||
| 637 | daniel-mar | 9089 | var range = SimRange.create; |
| 597 | daniel-mar | 9090 | var SimSelection = { |
| 9091 | domRange: domRange, |
||
| 9092 | relative: relative, |
||
| 9093 | exact: exact, |
||
| 9094 | exactFromRange: exactFromRange, |
||
| 9095 | getWin: getWin, |
||
| 637 | daniel-mar | 9096 | range: range |
| 597 | daniel-mar | 9097 | }; |
| 9098 | |||
| 637 | daniel-mar | 9099 | var selectNode = function (win, element) { |
| 9100 | var rng = win.document.createRange(); |
||
| 9101 | rng.selectNode(element.dom); |
||
| 9102 | return rng; |
||
| 9103 | }; |
||
| 597 | daniel-mar | 9104 | var selectNodeContents = function (win, element) { |
| 9105 | var rng = win.document.createRange(); |
||
| 9106 | selectNodeContentsUsing(rng, element); |
||
| 9107 | return rng; |
||
| 9108 | }; |
||
| 9109 | var selectNodeContentsUsing = function (rng, element) { |
||
| 9110 | return rng.selectNodeContents(element.dom); |
||
| 9111 | }; |
||
| 9112 | var setStart = function (rng, situ) { |
||
| 9113 | situ.fold(function (e) { |
||
| 9114 | rng.setStartBefore(e.dom); |
||
| 9115 | }, function (e, o) { |
||
| 9116 | rng.setStart(e.dom, o); |
||
| 9117 | }, function (e) { |
||
| 9118 | rng.setStartAfter(e.dom); |
||
| 9119 | }); |
||
| 9120 | }; |
||
| 9121 | var setFinish = function (rng, situ) { |
||
| 9122 | situ.fold(function (e) { |
||
| 9123 | rng.setEndBefore(e.dom); |
||
| 9124 | }, function (e, o) { |
||
| 9125 | rng.setEnd(e.dom, o); |
||
| 9126 | }, function (e) { |
||
| 9127 | rng.setEndAfter(e.dom); |
||
| 9128 | }); |
||
| 9129 | }; |
||
| 9130 | var relativeToNative = function (win, startSitu, finishSitu) { |
||
| 9131 | var range = win.document.createRange(); |
||
| 9132 | setStart(range, startSitu); |
||
| 9133 | setFinish(range, finishSitu); |
||
| 9134 | return range; |
||
| 9135 | }; |
||
| 9136 | var exactToNative = function (win, start, soffset, finish, foffset) { |
||
| 9137 | var rng = win.document.createRange(); |
||
| 9138 | rng.setStart(start.dom, soffset); |
||
| 9139 | rng.setEnd(finish.dom, foffset); |
||
| 9140 | return rng; |
||
| 9141 | }; |
||
| 9142 | var toRect = function (rect) { |
||
| 9143 | return { |
||
| 9144 | left: rect.left, |
||
| 9145 | top: rect.top, |
||
| 9146 | right: rect.right, |
||
| 9147 | bottom: rect.bottom, |
||
| 9148 | width: rect.width, |
||
| 9149 | height: rect.height |
||
| 9150 | }; |
||
| 9151 | }; |
||
| 637 | daniel-mar | 9152 | var getFirstRect$1 = function (rng) { |
| 597 | daniel-mar | 9153 | var rects = rng.getClientRects(); |
| 9154 | var rect = rects.length > 0 ? rects[0] : rng.getBoundingClientRect(); |
||
| 9155 | return rect.width > 0 || rect.height > 0 ? Optional.some(rect).map(toRect) : Optional.none(); |
||
| 9156 | }; |
||
| 9157 | |||
| 637 | daniel-mar | 9158 | var adt$2 = Adt.generate([ |
| 597 | daniel-mar | 9159 | { |
| 9160 | ltr: [ |
||
| 9161 | 'start', |
||
| 9162 | 'soffset', |
||
| 9163 | 'finish', |
||
| 9164 | 'foffset' |
||
| 9165 | ] |
||
| 9166 | }, |
||
| 9167 | { |
||
| 9168 | rtl: [ |
||
| 9169 | 'start', |
||
| 9170 | 'soffset', |
||
| 9171 | 'finish', |
||
| 9172 | 'foffset' |
||
| 9173 | ] |
||
| 9174 | } |
||
| 9175 | ]); |
||
| 9176 | var fromRange = function (win, type, range) { |
||
| 9177 | return type(SugarElement.fromDom(range.startContainer), range.startOffset, SugarElement.fromDom(range.endContainer), range.endOffset); |
||
| 9178 | }; |
||
| 9179 | var getRanges = function (win, selection) { |
||
| 9180 | return selection.match({ |
||
| 9181 | domRange: function (rng) { |
||
| 9182 | return { |
||
| 9183 | ltr: constant(rng), |
||
| 9184 | rtl: Optional.none |
||
| 9185 | }; |
||
| 9186 | }, |
||
| 9187 | relative: function (startSitu, finishSitu) { |
||
| 9188 | return { |
||
| 9189 | ltr: cached(function () { |
||
| 9190 | return relativeToNative(win, startSitu, finishSitu); |
||
| 9191 | }), |
||
| 9192 | rtl: cached(function () { |
||
| 9193 | return Optional.some(relativeToNative(win, finishSitu, startSitu)); |
||
| 9194 | }) |
||
| 9195 | }; |
||
| 9196 | }, |
||
| 9197 | exact: function (start, soffset, finish, foffset) { |
||
| 9198 | return { |
||
| 9199 | ltr: cached(function () { |
||
| 9200 | return exactToNative(win, start, soffset, finish, foffset); |
||
| 9201 | }), |
||
| 9202 | rtl: cached(function () { |
||
| 9203 | return Optional.some(exactToNative(win, finish, foffset, start, soffset)); |
||
| 9204 | }) |
||
| 9205 | }; |
||
| 9206 | } |
||
| 9207 | }); |
||
| 9208 | }; |
||
| 9209 | var doDiagnose = function (win, ranges) { |
||
| 9210 | var rng = ranges.ltr(); |
||
| 9211 | if (rng.collapsed) { |
||
| 9212 | var reversed = ranges.rtl().filter(function (rev) { |
||
| 9213 | return rev.collapsed === false; |
||
| 9214 | }); |
||
| 9215 | return reversed.map(function (rev) { |
||
| 637 | daniel-mar | 9216 | return adt$2.rtl(SugarElement.fromDom(rev.endContainer), rev.endOffset, SugarElement.fromDom(rev.startContainer), rev.startOffset); |
| 597 | daniel-mar | 9217 | }).getOrThunk(function () { |
| 637 | daniel-mar | 9218 | return fromRange(win, adt$2.ltr, rng); |
| 597 | daniel-mar | 9219 | }); |
| 9220 | } else { |
||
| 637 | daniel-mar | 9221 | return fromRange(win, adt$2.ltr, rng); |
| 597 | daniel-mar | 9222 | } |
| 9223 | }; |
||
| 9224 | var diagnose = function (win, selection) { |
||
| 9225 | var ranges = getRanges(win, selection); |
||
| 9226 | return doDiagnose(win, ranges); |
||
| 9227 | }; |
||
| 9228 | var asLtrRange = function (win, selection) { |
||
| 9229 | var diagnosis = diagnose(win, selection); |
||
| 9230 | return diagnosis.match({ |
||
| 9231 | ltr: function (start, soffset, finish, foffset) { |
||
| 9232 | var rng = win.document.createRange(); |
||
| 9233 | rng.setStart(start.dom, soffset); |
||
| 9234 | rng.setEnd(finish.dom, foffset); |
||
| 9235 | return rng; |
||
| 9236 | }, |
||
| 9237 | rtl: function (start, soffset, finish, foffset) { |
||
| 9238 | var rng = win.document.createRange(); |
||
| 9239 | rng.setStart(finish.dom, foffset); |
||
| 9240 | rng.setEnd(start.dom, soffset); |
||
| 9241 | return rng; |
||
| 9242 | } |
||
| 9243 | }); |
||
| 9244 | }; |
||
| 637 | daniel-mar | 9245 | adt$2.ltr; |
| 9246 | adt$2.rtl; |
||
| 597 | daniel-mar | 9247 | |
| 9248 | var searchForPoint = function (rectForOffset, x, y, maxX, length) { |
||
| 9249 | if (length === 0) { |
||
| 9250 | return 0; |
||
| 9251 | } else if (x === maxX) { |
||
| 9252 | return length - 1; |
||
| 9253 | } |
||
| 9254 | var xDelta = maxX; |
||
| 9255 | for (var i = 1; i < length; i++) { |
||
| 9256 | var rect = rectForOffset(i); |
||
| 9257 | var curDeltaX = Math.abs(x - rect.left); |
||
| 9258 | if (y <= rect.bottom) { |
||
| 9259 | if (y < rect.top || curDeltaX > xDelta) { |
||
| 9260 | return i - 1; |
||
| 9261 | } else { |
||
| 9262 | xDelta = curDeltaX; |
||
| 9263 | } |
||
| 9264 | } |
||
| 9265 | } |
||
| 9266 | return 0; |
||
| 9267 | }; |
||
| 9268 | var inRect = function (rect, x, y) { |
||
| 9269 | return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom; |
||
| 9270 | }; |
||
| 9271 | |||
| 9272 | var locateOffset = function (doc, textnode, x, y, rect) { |
||
| 9273 | var rangeForOffset = function (o) { |
||
| 9274 | var r = doc.dom.createRange(); |
||
| 9275 | r.setStart(textnode.dom, o); |
||
| 9276 | r.collapse(true); |
||
| 9277 | return r; |
||
| 9278 | }; |
||
| 9279 | var rectForOffset = function (o) { |
||
| 9280 | var r = rangeForOffset(o); |
||
| 9281 | return r.getBoundingClientRect(); |
||
| 9282 | }; |
||
| 637 | daniel-mar | 9283 | var length = get$9(textnode).length; |
| 597 | daniel-mar | 9284 | var offset = searchForPoint(rectForOffset, x, y, rect.right, length); |
| 9285 | return rangeForOffset(offset); |
||
| 9286 | }; |
||
| 637 | daniel-mar | 9287 | var locate$1 = function (doc, node, x, y) { |
| 597 | daniel-mar | 9288 | var r = doc.dom.createRange(); |
| 9289 | r.selectNode(node.dom); |
||
| 9290 | var rects = r.getClientRects(); |
||
| 9291 | var foundRect = findMap(rects, function (rect) { |
||
| 9292 | return inRect(rect, x, y) ? Optional.some(rect) : Optional.none(); |
||
| 9293 | }); |
||
| 9294 | return foundRect.map(function (rect) { |
||
| 9295 | return locateOffset(doc, node, x, y, rect); |
||
| 9296 | }); |
||
| 9297 | }; |
||
| 9298 | |||
| 9299 | var searchInChildren = function (doc, node, x, y) { |
||
| 9300 | var r = doc.dom.createRange(); |
||
| 637 | daniel-mar | 9301 | var nodes = children$3(node); |
| 597 | daniel-mar | 9302 | return findMap(nodes, function (n) { |
| 9303 | r.selectNode(n.dom); |
||
| 9304 | return inRect(r.getBoundingClientRect(), x, y) ? locateNode(doc, n, x, y) : Optional.none(); |
||
| 9305 | }); |
||
| 9306 | }; |
||
| 9307 | var locateNode = function (doc, node, x, y) { |
||
| 637 | daniel-mar | 9308 | return isText(node) ? locate$1(doc, node, x, y) : searchInChildren(doc, node, x, y); |
| 597 | daniel-mar | 9309 | }; |
| 637 | daniel-mar | 9310 | var locate = function (doc, node, x, y) { |
| 597 | daniel-mar | 9311 | var r = doc.dom.createRange(); |
| 9312 | r.selectNode(node.dom); |
||
| 9313 | var rect = r.getBoundingClientRect(); |
||
| 9314 | var boundedX = Math.max(rect.left, Math.min(rect.right, x)); |
||
| 9315 | var boundedY = Math.max(rect.top, Math.min(rect.bottom, y)); |
||
| 9316 | return locateNode(doc, node, boundedX, boundedY); |
||
| 9317 | }; |
||
| 9318 | |||
| 9319 | var COLLAPSE_TO_LEFT = true; |
||
| 9320 | var COLLAPSE_TO_RIGHT = false; |
||
| 9321 | var getCollapseDirection = function (rect, x) { |
||
| 9322 | return x - rect.left < rect.right - x ? COLLAPSE_TO_LEFT : COLLAPSE_TO_RIGHT; |
||
| 9323 | }; |
||
| 9324 | var createCollapsedNode = function (doc, target, collapseDirection) { |
||
| 9325 | var r = doc.dom.createRange(); |
||
| 9326 | r.selectNode(target.dom); |
||
| 9327 | r.collapse(collapseDirection); |
||
| 9328 | return r; |
||
| 9329 | }; |
||
| 9330 | var locateInElement = function (doc, node, x) { |
||
| 9331 | var cursorRange = doc.dom.createRange(); |
||
| 9332 | cursorRange.selectNode(node.dom); |
||
| 9333 | var rect = cursorRange.getBoundingClientRect(); |
||
| 9334 | var collapseDirection = getCollapseDirection(rect, x); |
||
| 9335 | var f = collapseDirection === COLLAPSE_TO_LEFT ? first : last$1; |
||
| 9336 | return f(node).map(function (target) { |
||
| 9337 | return createCollapsedNode(doc, target, collapseDirection); |
||
| 9338 | }); |
||
| 9339 | }; |
||
| 9340 | var locateInEmpty = function (doc, node, x) { |
||
| 9341 | var rect = node.dom.getBoundingClientRect(); |
||
| 9342 | var collapseDirection = getCollapseDirection(rect, x); |
||
| 9343 | return Optional.some(createCollapsedNode(doc, node, collapseDirection)); |
||
| 9344 | }; |
||
| 9345 | var search = function (doc, node, x) { |
||
| 637 | daniel-mar | 9346 | var f = children$3(node).length === 0 ? locateInEmpty : locateInElement; |
| 597 | daniel-mar | 9347 | return f(doc, node, x); |
| 9348 | }; |
||
| 9349 | |||
| 9350 | var caretPositionFromPoint = function (doc, x, y) { |
||
| 637 | daniel-mar | 9351 | var _a, _b; |
| 9352 | return Optional.from((_b = (_a = doc.dom).caretPositionFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y)).bind(function (pos) { |
||
| 597 | daniel-mar | 9353 | if (pos.offsetNode === null) { |
| 9354 | return Optional.none(); |
||
| 9355 | } |
||
| 9356 | var r = doc.dom.createRange(); |
||
| 9357 | r.setStart(pos.offsetNode, pos.offset); |
||
| 9358 | r.collapse(); |
||
| 9359 | return Optional.some(r); |
||
| 9360 | }); |
||
| 9361 | }; |
||
| 9362 | var caretRangeFromPoint = function (doc, x, y) { |
||
| 637 | daniel-mar | 9363 | var _a, _b; |
| 9364 | return Optional.from((_b = (_a = doc.dom).caretRangeFromPoint) === null || _b === void 0 ? void 0 : _b.call(_a, x, y)); |
||
| 597 | daniel-mar | 9365 | }; |
| 9366 | var searchTextNodes = function (doc, node, x, y) { |
||
| 9367 | var r = doc.dom.createRange(); |
||
| 9368 | r.selectNode(node.dom); |
||
| 9369 | var rect = r.getBoundingClientRect(); |
||
| 9370 | var boundedX = Math.max(rect.left, Math.min(rect.right, x)); |
||
| 9371 | var boundedY = Math.max(rect.top, Math.min(rect.bottom, y)); |
||
| 637 | daniel-mar | 9372 | return locate(doc, node, boundedX, boundedY); |
| 597 | daniel-mar | 9373 | }; |
| 9374 | var searchFromPoint = function (doc, x, y) { |
||
| 9375 | return SugarElement.fromPoint(doc, x, y).bind(function (elem) { |
||
| 9376 | var fallback = function () { |
||
| 9377 | return search(doc, elem, x); |
||
| 9378 | }; |
||
| 637 | daniel-mar | 9379 | return children$3(elem).length === 0 ? fallback() : searchTextNodes(doc, elem, x, y).orThunk(fallback); |
| 597 | daniel-mar | 9380 | }); |
| 9381 | }; |
||
| 9382 | var availableSearch = function () { |
||
| 9383 | if (document.caretPositionFromPoint) { |
||
| 9384 | return caretPositionFromPoint; |
||
| 9385 | } else if (document.caretRangeFromPoint) { |
||
| 9386 | return caretRangeFromPoint; |
||
| 9387 | } else { |
||
| 9388 | return searchFromPoint; |
||
| 9389 | } |
||
| 9390 | }(); |
||
| 637 | daniel-mar | 9391 | var fromPoint = function (win, x, y) { |
| 597 | daniel-mar | 9392 | var doc = SugarElement.fromDom(win.document); |
| 9393 | return availableSearch(doc, x, y).map(function (rng) { |
||
| 9394 | return SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset); |
||
| 9395 | }); |
||
| 9396 | }; |
||
| 9397 | |||
| 9398 | var beforeSpecial = function (element, offset) { |
||
| 9399 | var name$1 = name(element); |
||
| 9400 | if ('input' === name$1) { |
||
| 9401 | return Situ.after(element); |
||
| 637 | daniel-mar | 9402 | } else if (!contains$2([ |
| 597 | daniel-mar | 9403 | 'br', |
| 9404 | 'img' |
||
| 9405 | ], name$1)) { |
||
| 9406 | return Situ.on(element, offset); |
||
| 9407 | } else { |
||
| 9408 | return offset === 0 ? Situ.before(element) : Situ.after(element); |
||
| 9409 | } |
||
| 9410 | }; |
||
| 9411 | var preprocessRelative = function (startSitu, finishSitu) { |
||
| 9412 | var start = startSitu.fold(Situ.before, beforeSpecial, Situ.after); |
||
| 9413 | var finish = finishSitu.fold(Situ.before, beforeSpecial, Situ.after); |
||
| 9414 | return SimSelection.relative(start, finish); |
||
| 9415 | }; |
||
| 9416 | var preprocessExact = function (start, soffset, finish, foffset) { |
||
| 9417 | var startSitu = beforeSpecial(start, soffset); |
||
| 9418 | var finishSitu = beforeSpecial(finish, foffset); |
||
| 9419 | return SimSelection.relative(startSitu, finishSitu); |
||
| 9420 | }; |
||
| 9421 | var preprocess = function (selection) { |
||
| 9422 | return selection.match({ |
||
| 9423 | domRange: function (rng) { |
||
| 9424 | var start = SugarElement.fromDom(rng.startContainer); |
||
| 9425 | var finish = SugarElement.fromDom(rng.endContainer); |
||
| 9426 | return preprocessExact(start, rng.startOffset, finish, rng.endOffset); |
||
| 9427 | }, |
||
| 9428 | relative: preprocessRelative, |
||
| 9429 | exact: preprocessExact |
||
| 9430 | }); |
||
| 9431 | }; |
||
| 9432 | |||
| 9433 | var makeRange = function (start, soffset, finish, foffset) { |
||
| 9434 | var doc = owner(start); |
||
| 9435 | var rng = doc.dom.createRange(); |
||
| 9436 | rng.setStart(start.dom, soffset); |
||
| 9437 | rng.setEnd(finish.dom, foffset); |
||
| 9438 | return rng; |
||
| 9439 | }; |
||
| 637 | daniel-mar | 9440 | var after$2 = function (start, soffset, finish, foffset) { |
| 597 | daniel-mar | 9441 | var r = makeRange(start, soffset, finish, foffset); |
| 9442 | var same = eq$1(start, finish) && soffset === foffset; |
||
| 9443 | return r.collapsed && !same; |
||
| 9444 | }; |
||
| 9445 | |||
| 9446 | var getNativeSelection = function (win) { |
||
| 9447 | return Optional.from(win.getSelection()); |
||
| 9448 | }; |
||
| 9449 | var doSetNativeRange = function (win, rng) { |
||
| 9450 | getNativeSelection(win).each(function (selection) { |
||
| 9451 | selection.removeAllRanges(); |
||
| 9452 | selection.addRange(rng); |
||
| 9453 | }); |
||
| 9454 | }; |
||
| 9455 | var doSetRange = function (win, start, soffset, finish, foffset) { |
||
| 9456 | var rng = exactToNative(win, start, soffset, finish, foffset); |
||
| 9457 | doSetNativeRange(win, rng); |
||
| 9458 | }; |
||
| 9459 | var setLegacyRtlRange = function (win, selection, start, soffset, finish, foffset) { |
||
| 9460 | selection.collapse(start.dom, soffset); |
||
| 9461 | selection.extend(finish.dom, foffset); |
||
| 9462 | }; |
||
| 9463 | var setRangeFromRelative = function (win, relative) { |
||
| 9464 | return diagnose(win, relative).match({ |
||
| 9465 | ltr: function (start, soffset, finish, foffset) { |
||
| 9466 | doSetRange(win, start, soffset, finish, foffset); |
||
| 9467 | }, |
||
| 9468 | rtl: function (start, soffset, finish, foffset) { |
||
| 9469 | getNativeSelection(win).each(function (selection) { |
||
| 9470 | if (selection.setBaseAndExtent) { |
||
| 9471 | selection.setBaseAndExtent(start.dom, soffset, finish.dom, foffset); |
||
| 9472 | } else if (selection.extend) { |
||
| 9473 | try { |
||
| 9474 | setLegacyRtlRange(win, selection, start, soffset, finish, foffset); |
||
| 9475 | } catch (e) { |
||
| 9476 | doSetRange(win, finish, foffset, start, soffset); |
||
| 9477 | } |
||
| 9478 | } else { |
||
| 9479 | doSetRange(win, finish, foffset, start, soffset); |
||
| 9480 | } |
||
| 9481 | }); |
||
| 9482 | } |
||
| 9483 | }); |
||
| 9484 | }; |
||
| 9485 | var setExact = function (win, start, soffset, finish, foffset) { |
||
| 9486 | var relative = preprocessExact(start, soffset, finish, foffset); |
||
| 9487 | setRangeFromRelative(win, relative); |
||
| 9488 | }; |
||
| 9489 | var setRelative = function (win, startSitu, finishSitu) { |
||
| 9490 | var relative = preprocessRelative(startSitu, finishSitu); |
||
| 9491 | setRangeFromRelative(win, relative); |
||
| 9492 | }; |
||
| 9493 | var toNative = function (selection) { |
||
| 9494 | var win = SimSelection.getWin(selection).dom; |
||
| 9495 | var getDomRange = function (start, soffset, finish, foffset) { |
||
| 9496 | return exactToNative(win, start, soffset, finish, foffset); |
||
| 9497 | }; |
||
| 9498 | var filtered = preprocess(selection); |
||
| 9499 | return diagnose(win, filtered).match({ |
||
| 9500 | ltr: getDomRange, |
||
| 9501 | rtl: getDomRange |
||
| 9502 | }); |
||
| 9503 | }; |
||
| 9504 | var readRange = function (selection) { |
||
| 9505 | if (selection.rangeCount > 0) { |
||
| 9506 | var firstRng = selection.getRangeAt(0); |
||
| 9507 | var lastRng = selection.getRangeAt(selection.rangeCount - 1); |
||
| 9508 | return Optional.some(SimRange.create(SugarElement.fromDom(firstRng.startContainer), firstRng.startOffset, SugarElement.fromDom(lastRng.endContainer), lastRng.endOffset)); |
||
| 9509 | } else { |
||
| 9510 | return Optional.none(); |
||
| 9511 | } |
||
| 9512 | }; |
||
| 9513 | var doGetExact = function (selection) { |
||
| 9514 | if (selection.anchorNode === null || selection.focusNode === null) { |
||
| 9515 | return readRange(selection); |
||
| 9516 | } else { |
||
| 9517 | var anchor = SugarElement.fromDom(selection.anchorNode); |
||
| 9518 | var focus_1 = SugarElement.fromDom(selection.focusNode); |
||
| 637 | daniel-mar | 9519 | return after$2(anchor, selection.anchorOffset, focus_1, selection.focusOffset) ? Optional.some(SimRange.create(anchor, selection.anchorOffset, focus_1, selection.focusOffset)) : readRange(selection); |
| 597 | daniel-mar | 9520 | } |
| 9521 | }; |
||
| 637 | daniel-mar | 9522 | var setToElement = function (win, element, selectNodeContents$1) { |
| 9523 | if (selectNodeContents$1 === void 0) { |
||
| 9524 | selectNodeContents$1 = true; |
||
| 9525 | } |
||
| 9526 | var rngGetter = selectNodeContents$1 ? selectNodeContents : selectNode; |
||
| 9527 | var rng = rngGetter(win, element); |
||
| 597 | daniel-mar | 9528 | doSetNativeRange(win, rng); |
| 9529 | }; |
||
| 9530 | var getExact = function (win) { |
||
| 9531 | return getNativeSelection(win).filter(function (sel) { |
||
| 9532 | return sel.rangeCount > 0; |
||
| 9533 | }).bind(doGetExact); |
||
| 9534 | }; |
||
| 637 | daniel-mar | 9535 | var get$1 = function (win) { |
| 597 | daniel-mar | 9536 | return getExact(win).map(function (range) { |
| 9537 | return SimSelection.exact(range.start, range.soffset, range.finish, range.foffset); |
||
| 9538 | }); |
||
| 9539 | }; |
||
| 637 | daniel-mar | 9540 | var getFirstRect = function (win, selection) { |
| 597 | daniel-mar | 9541 | var rng = asLtrRange(win, selection); |
| 637 | daniel-mar | 9542 | return getFirstRect$1(rng); |
| 597 | daniel-mar | 9543 | }; |
| 9544 | var getAtPoint = function (win, x, y) { |
||
| 637 | daniel-mar | 9545 | return fromPoint(win, x, y); |
| 597 | daniel-mar | 9546 | }; |
| 9547 | var clear = function (win) { |
||
| 9548 | getNativeSelection(win).each(function (selection) { |
||
| 9549 | return selection.removeAllRanges(); |
||
| 9550 | }); |
||
| 9551 | }; |
||
| 9552 | |||
| 637 | daniel-mar | 9553 | var global$1 = tinymce.util.Tools.resolve('tinymce.util.VK'); |
| 597 | daniel-mar | 9554 | |
| 9555 | var forward = function (editor, isRoot, cell) { |
||
| 637 | daniel-mar | 9556 | return go$1(editor, isRoot, next(cell, isEditable$1)); |
| 597 | daniel-mar | 9557 | }; |
| 9558 | var backward = function (editor, isRoot, cell) { |
||
| 637 | daniel-mar | 9559 | return go$1(editor, isRoot, prev(cell, isEditable$1)); |
| 597 | daniel-mar | 9560 | }; |
| 9561 | var getCellFirstCursorPosition = function (editor, cell) { |
||
| 9562 | var selection = SimSelection.exact(cell, 0, cell, 0); |
||
| 9563 | return toNative(selection); |
||
| 9564 | }; |
||
| 637 | daniel-mar | 9565 | var go$1 = function (editor, isRoot, cell) { |
| 597 | daniel-mar | 9566 | return cell.fold(Optional.none, Optional.none, function (current, next) { |
| 9567 | return first(next).map(function (cell) { |
||
| 9568 | return getCellFirstCursorPosition(editor, cell); |
||
| 9569 | }); |
||
| 9570 | }, function (current) { |
||
| 637 | daniel-mar | 9571 | editor.execCommand('mceTableInsertRowAfter'); |
| 9572 | return forward(editor, isRoot, current); |
||
| 597 | daniel-mar | 9573 | }); |
| 9574 | }; |
||
| 9575 | var rootElements = [ |
||
| 9576 | 'table', |
||
| 9577 | 'li', |
||
| 9578 | 'dl' |
||
| 9579 | ]; |
||
| 9580 | var handle$1 = function (event, editor, cellSelection) { |
||
| 637 | daniel-mar | 9581 | if (event.keyCode === global$1.TAB) { |
| 9582 | var body_1 = getBody(editor); |
||
| 597 | daniel-mar | 9583 | var isRoot_1 = function (element) { |
| 9584 | var name$1 = name(element); |
||
| 637 | daniel-mar | 9585 | return eq$1(element, body_1) || contains$2(rootElements, name$1); |
| 597 | daniel-mar | 9586 | }; |
| 9587 | var rng = editor.selection.getRng(); |
||
| 9588 | var container = SugarElement.fromDom(event.shiftKey ? rng.startContainer : rng.endContainer); |
||
| 9589 | cell(container, isRoot_1).each(function (cell) { |
||
| 9590 | event.preventDefault(); |
||
| 9591 | table(cell, isRoot_1).each(cellSelection.clear); |
||
| 9592 | editor.selection.collapse(event.shiftKey); |
||
| 9593 | var navigation = event.shiftKey ? backward : forward; |
||
| 9594 | var rng = navigation(editor, isRoot_1, cell); |
||
| 9595 | rng.each(function (range) { |
||
| 9596 | editor.selection.setRng(range); |
||
| 9597 | }); |
||
| 9598 | }); |
||
| 9599 | } |
||
| 9600 | }; |
||
| 9601 | |||
| 637 | daniel-mar | 9602 | var create$1 = function (selection, kill) { |
| 597 | daniel-mar | 9603 | return { |
| 9604 | selection: selection, |
||
| 9605 | kill: kill |
||
| 9606 | }; |
||
| 9607 | }; |
||
| 637 | daniel-mar | 9608 | var Response = { create: create$1 }; |
| 597 | daniel-mar | 9609 | |
| 637 | daniel-mar | 9610 | var create = function (start, soffset, finish, foffset) { |
| 597 | daniel-mar | 9611 | return { |
| 9612 | start: Situ.on(start, soffset), |
||
| 9613 | finish: Situ.on(finish, foffset) |
||
| 9614 | }; |
||
| 9615 | }; |
||
| 637 | daniel-mar | 9616 | var Situs = { create: create }; |
| 597 | daniel-mar | 9617 | |
| 9618 | var convertToRange = function (win, selection) { |
||
| 9619 | var rng = asLtrRange(win, selection); |
||
| 9620 | return SimRange.create(SugarElement.fromDom(rng.startContainer), rng.startOffset, SugarElement.fromDom(rng.endContainer), rng.endOffset); |
||
| 9621 | }; |
||
| 9622 | var makeSitus = Situs.create; |
||
| 9623 | |||
| 9624 | var sync = function (container, isRoot, start, soffset, finish, foffset, selectRange) { |
||
| 9625 | if (!(eq$1(start, finish) && soffset === foffset)) { |
||
| 9626 | return closest$1(start, 'td,th', isRoot).bind(function (s) { |
||
| 9627 | return closest$1(finish, 'td,th', isRoot).bind(function (f) { |
||
| 637 | daniel-mar | 9628 | return detect(container, isRoot, s, f, selectRange); |
| 597 | daniel-mar | 9629 | }); |
| 9630 | }); |
||
| 9631 | } else { |
||
| 9632 | return Optional.none(); |
||
| 9633 | } |
||
| 9634 | }; |
||
| 637 | daniel-mar | 9635 | var detect = function (container, isRoot, start, finish, selectRange) { |
| 597 | daniel-mar | 9636 | if (!eq$1(start, finish)) { |
| 9637 | return identify(start, finish, isRoot).bind(function (cellSel) { |
||
| 9638 | var boxes = cellSel.boxes.getOr([]); |
||
| 637 | daniel-mar | 9639 | if (boxes.length > 1) { |
| 597 | daniel-mar | 9640 | selectRange(container, boxes, cellSel.start, cellSel.finish); |
| 9641 | return Optional.some(Response.create(Optional.some(makeSitus(start, 0, start, getEnd(start))), true)); |
||
| 9642 | } else { |
||
| 9643 | return Optional.none(); |
||
| 9644 | } |
||
| 9645 | }); |
||
| 9646 | } else { |
||
| 9647 | return Optional.none(); |
||
| 9648 | } |
||
| 9649 | }; |
||
| 9650 | var update = function (rows, columns, container, selected, annotations) { |
||
| 9651 | var updateSelection = function (newSels) { |
||
| 9652 | annotations.clearBeforeUpdate(container); |
||
| 9653 | annotations.selectRange(container, newSels.boxes, newSels.start, newSels.finish); |
||
| 9654 | return newSels.boxes; |
||
| 9655 | }; |
||
| 9656 | return shiftSelection(selected, rows, columns, annotations.firstSelectedSelector, annotations.lastSelectedSelector).map(updateSelection); |
||
| 9657 | }; |
||
| 9658 | |||
| 9659 | var traverse = function (item, mode) { |
||
| 9660 | return { |
||
| 9661 | item: item, |
||
| 9662 | mode: mode |
||
| 9663 | }; |
||
| 9664 | }; |
||
| 9665 | var backtrack = function (universe, item, _direction, transition) { |
||
| 9666 | if (transition === void 0) { |
||
| 9667 | transition = sidestep; |
||
| 9668 | } |
||
| 9669 | return universe.property().parent(item).map(function (p) { |
||
| 9670 | return traverse(p, transition); |
||
| 9671 | }); |
||
| 9672 | }; |
||
| 9673 | var sidestep = function (universe, item, direction, transition) { |
||
| 9674 | if (transition === void 0) { |
||
| 9675 | transition = advance; |
||
| 9676 | } |
||
| 9677 | return direction.sibling(universe, item).map(function (p) { |
||
| 9678 | return traverse(p, transition); |
||
| 9679 | }); |
||
| 9680 | }; |
||
| 9681 | var advance = function (universe, item, direction, transition) { |
||
| 9682 | if (transition === void 0) { |
||
| 9683 | transition = advance; |
||
| 9684 | } |
||
| 9685 | var children = universe.property().children(item); |
||
| 9686 | var result = direction.first(children); |
||
| 9687 | return result.map(function (r) { |
||
| 9688 | return traverse(r, transition); |
||
| 9689 | }); |
||
| 9690 | }; |
||
| 9691 | var successors = [ |
||
| 9692 | { |
||
| 9693 | current: backtrack, |
||
| 9694 | next: sidestep, |
||
| 9695 | fallback: Optional.none() |
||
| 9696 | }, |
||
| 9697 | { |
||
| 9698 | current: sidestep, |
||
| 9699 | next: advance, |
||
| 9700 | fallback: Optional.some(backtrack) |
||
| 9701 | }, |
||
| 9702 | { |
||
| 9703 | current: advance, |
||
| 9704 | next: advance, |
||
| 9705 | fallback: Optional.some(sidestep) |
||
| 9706 | } |
||
| 9707 | ]; |
||
| 637 | daniel-mar | 9708 | var go = function (universe, item, mode, direction, rules) { |
| 597 | daniel-mar | 9709 | if (rules === void 0) { |
| 9710 | rules = successors; |
||
| 9711 | } |
||
| 637 | daniel-mar | 9712 | var ruleOpt = find$1(rules, function (succ) { |
| 597 | daniel-mar | 9713 | return succ.current === mode; |
| 9714 | }); |
||
| 9715 | return ruleOpt.bind(function (rule) { |
||
| 9716 | return rule.current(universe, item, direction, rule.next).orThunk(function () { |
||
| 9717 | return rule.fallback.bind(function (fb) { |
||
| 637 | daniel-mar | 9718 | return go(universe, item, fb, direction); |
| 597 | daniel-mar | 9719 | }); |
| 9720 | }); |
||
| 9721 | }); |
||
| 9722 | }; |
||
| 9723 | |||
| 637 | daniel-mar | 9724 | var left$1 = function () { |
| 597 | daniel-mar | 9725 | var sibling = function (universe, item) { |
| 9726 | return universe.query().prevSibling(item); |
||
| 9727 | }; |
||
| 9728 | var first = function (children) { |
||
| 9729 | return children.length > 0 ? Optional.some(children[children.length - 1]) : Optional.none(); |
||
| 9730 | }; |
||
| 9731 | return { |
||
| 9732 | sibling: sibling, |
||
| 9733 | first: first |
||
| 9734 | }; |
||
| 9735 | }; |
||
| 637 | daniel-mar | 9736 | var right$1 = function () { |
| 597 | daniel-mar | 9737 | var sibling = function (universe, item) { |
| 9738 | return universe.query().nextSibling(item); |
||
| 9739 | }; |
||
| 9740 | var first = function (children) { |
||
| 9741 | return children.length > 0 ? Optional.some(children[0]) : Optional.none(); |
||
| 9742 | }; |
||
| 9743 | return { |
||
| 9744 | sibling: sibling, |
||
| 9745 | first: first |
||
| 9746 | }; |
||
| 9747 | }; |
||
| 9748 | var Walkers = { |
||
| 637 | daniel-mar | 9749 | left: left$1, |
| 9750 | right: right$1 |
||
| 597 | daniel-mar | 9751 | }; |
| 9752 | |||
| 9753 | var hone = function (universe, item, predicate, mode, direction, isRoot) { |
||
| 637 | daniel-mar | 9754 | var next = go(universe, item, mode, direction); |
| 597 | daniel-mar | 9755 | return next.bind(function (n) { |
| 9756 | if (isRoot(n.item)) { |
||
| 9757 | return Optional.none(); |
||
| 9758 | } else { |
||
| 9759 | return predicate(n.item) ? Optional.some(n.item) : hone(universe, n.item, predicate, n.mode, direction, isRoot); |
||
| 9760 | } |
||
| 9761 | }); |
||
| 9762 | }; |
||
| 637 | daniel-mar | 9763 | var left = function (universe, item, predicate, isRoot) { |
| 597 | daniel-mar | 9764 | return hone(universe, item, predicate, sidestep, Walkers.left(), isRoot); |
| 9765 | }; |
||
| 637 | daniel-mar | 9766 | var right = function (universe, item, predicate, isRoot) { |
| 597 | daniel-mar | 9767 | return hone(universe, item, predicate, sidestep, Walkers.right(), isRoot); |
| 9768 | }; |
||
| 9769 | |||
| 9770 | var isLeaf = function (universe) { |
||
| 9771 | return function (element) { |
||
| 9772 | return universe.property().children(element).length === 0; |
||
| 9773 | }; |
||
| 9774 | }; |
||
| 637 | daniel-mar | 9775 | var before$1 = function (universe, item, isRoot) { |
| 9776 | return seekLeft$1(universe, item, isLeaf(universe), isRoot); |
||
| 597 | daniel-mar | 9777 | }; |
| 637 | daniel-mar | 9778 | var after$1 = function (universe, item, isRoot) { |
| 9779 | return seekRight$1(universe, item, isLeaf(universe), isRoot); |
||
| 597 | daniel-mar | 9780 | }; |
| 637 | daniel-mar | 9781 | var seekLeft$1 = left; |
| 9782 | var seekRight$1 = right; |
||
| 597 | daniel-mar | 9783 | |
| 637 | daniel-mar | 9784 | var universe = DomUniverse(); |
| 9785 | var before = function (element, isRoot) { |
||
| 9786 | return before$1(universe, element, isRoot); |
||
| 597 | daniel-mar | 9787 | }; |
| 637 | daniel-mar | 9788 | var after = function (element, isRoot) { |
| 9789 | return after$1(universe, element, isRoot); |
||
| 597 | daniel-mar | 9790 | }; |
| 637 | daniel-mar | 9791 | var seekLeft = function (element, predicate, isRoot) { |
| 9792 | return seekLeft$1(universe, element, predicate, isRoot); |
||
| 597 | daniel-mar | 9793 | }; |
| 637 | daniel-mar | 9794 | var seekRight = function (element, predicate, isRoot) { |
| 9795 | return seekRight$1(universe, element, predicate, isRoot); |
||
| 597 | daniel-mar | 9796 | }; |
| 9797 | |||
| 637 | daniel-mar | 9798 | var ancestor = function (scope, predicate, isRoot) { |
| 9799 | return ancestor$2(scope, predicate, isRoot).isSome(); |
||
| 597 | daniel-mar | 9800 | }; |
| 9801 | |||
| 637 | daniel-mar | 9802 | var adt$1 = Adt.generate([ |
| 597 | daniel-mar | 9803 | { none: ['message'] }, |
| 9804 | { success: [] }, |
||
| 9805 | { failedUp: ['cell'] }, |
||
| 9806 | { failedDown: ['cell'] } |
||
| 9807 | ]); |
||
| 9808 | var isOverlapping = function (bridge, before, after) { |
||
| 9809 | var beforeBounds = bridge.getRect(before); |
||
| 9810 | var afterBounds = bridge.getRect(after); |
||
| 9811 | return afterBounds.right > beforeBounds.left && afterBounds.left < beforeBounds.right; |
||
| 9812 | }; |
||
| 9813 | var isRow = function (elem) { |
||
| 9814 | return closest$1(elem, 'tr'); |
||
| 9815 | }; |
||
| 9816 | var verify = function (bridge, before, beforeOffset, after, afterOffset, failure, isRoot) { |
||
| 9817 | return closest$1(after, 'td,th', isRoot).bind(function (afterCell) { |
||
| 9818 | return closest$1(before, 'td,th', isRoot).map(function (beforeCell) { |
||
| 9819 | if (!eq$1(afterCell, beforeCell)) { |
||
| 637 | daniel-mar | 9820 | return sharedOne(isRow, [ |
| 597 | daniel-mar | 9821 | afterCell, |
| 9822 | beforeCell |
||
| 9823 | ]).fold(function () { |
||
| 637 | daniel-mar | 9824 | return isOverlapping(bridge, beforeCell, afterCell) ? adt$1.success() : failure(beforeCell); |
| 597 | daniel-mar | 9825 | }, function (_sharedRow) { |
| 9826 | return failure(beforeCell); |
||
| 9827 | }); |
||
| 9828 | } else { |
||
| 637 | daniel-mar | 9829 | return eq$1(after, afterCell) && getEnd(afterCell) === afterOffset ? failure(beforeCell) : adt$1.none('in same cell'); |
| 597 | daniel-mar | 9830 | } |
| 9831 | }); |
||
| 637 | daniel-mar | 9832 | }).getOr(adt$1.none('default')); |
| 597 | daniel-mar | 9833 | }; |
| 637 | daniel-mar | 9834 | var cata = function (subject, onNone, onSuccess, onFailedUp, onFailedDown) { |
| 597 | daniel-mar | 9835 | return subject.fold(onNone, onSuccess, onFailedUp, onFailedDown); |
| 9836 | }; |
||
| 637 | daniel-mar | 9837 | var BeforeAfter = __assign(__assign({}, adt$1), { |
| 597 | daniel-mar | 9838 | verify: verify, |
| 637 | daniel-mar | 9839 | cata: cata |
| 597 | daniel-mar | 9840 | }); |
| 9841 | |||
| 9842 | var inParent = function (parent, children, element, index) { |
||
| 9843 | return { |
||
| 9844 | parent: parent, |
||
| 9845 | children: children, |
||
| 9846 | element: element, |
||
| 9847 | index: index |
||
| 9848 | }; |
||
| 9849 | }; |
||
| 9850 | var indexInParent = function (element) { |
||
| 9851 | return parent(element).bind(function (parent) { |
||
| 637 | daniel-mar | 9852 | var children = children$3(parent); |
| 9853 | return indexOf(children, element).map(function (index) { |
||
| 9854 | return inParent(parent, children, element, index); |
||
| 597 | daniel-mar | 9855 | }); |
| 9856 | }); |
||
| 9857 | }; |
||
| 9858 | var indexOf = function (elements, element) { |
||
| 9859 | return findIndex(elements, curry(eq$1, element)); |
||
| 9860 | }; |
||
| 9861 | |||
| 9862 | var isBr = function (elem) { |
||
| 9863 | return name(elem) === 'br'; |
||
| 9864 | }; |
||
| 9865 | var gatherer = function (cand, gather, isRoot) { |
||
| 9866 | return gather(cand, isRoot).bind(function (target) { |
||
| 637 | daniel-mar | 9867 | return isText(target) && get$9(target).trim().length === 0 ? gatherer(target, gather, isRoot) : Optional.some(target); |
| 597 | daniel-mar | 9868 | }); |
| 9869 | }; |
||
| 9870 | var handleBr = function (isRoot, element, direction) { |
||
| 9871 | return direction.traverse(element).orThunk(function () { |
||
| 9872 | return gatherer(element, direction.gather, isRoot); |
||
| 9873 | }).map(direction.relative); |
||
| 9874 | }; |
||
| 9875 | var findBr = function (element, offset) { |
||
| 637 | daniel-mar | 9876 | return child$3(element, offset).filter(isBr).orThunk(function () { |
| 9877 | return child$3(element, offset - 1).filter(isBr); |
||
| 597 | daniel-mar | 9878 | }); |
| 9879 | }; |
||
| 9880 | var handleParent = function (isRoot, element, offset, direction) { |
||
| 9881 | return findBr(element, offset).bind(function (br) { |
||
| 9882 | return direction.traverse(br).fold(function () { |
||
| 9883 | return gatherer(br, direction.gather, isRoot).map(direction.relative); |
||
| 9884 | }, function (adjacent) { |
||
| 9885 | return indexInParent(adjacent).map(function (info) { |
||
| 9886 | return Situ.on(info.parent, info.index); |
||
| 9887 | }); |
||
| 9888 | }); |
||
| 9889 | }); |
||
| 9890 | }; |
||
| 9891 | var tryBr = function (isRoot, element, offset, direction) { |
||
| 9892 | var target = isBr(element) ? handleBr(isRoot, element, direction) : handleParent(isRoot, element, offset, direction); |
||
| 9893 | return target.map(function (tgt) { |
||
| 9894 | return { |
||
| 9895 | start: tgt, |
||
| 9896 | finish: tgt |
||
| 9897 | }; |
||
| 9898 | }); |
||
| 9899 | }; |
||
| 9900 | var process = function (analysis) { |
||
| 9901 | return BeforeAfter.cata(analysis, function (_message) { |
||
| 9902 | return Optional.none(); |
||
| 9903 | }, function () { |
||
| 9904 | return Optional.none(); |
||
| 9905 | }, function (cell) { |
||
| 9906 | return Optional.some(point(cell, 0)); |
||
| 9907 | }, function (cell) { |
||
| 9908 | return Optional.some(point(cell, getEnd(cell))); |
||
| 9909 | }); |
||
| 9910 | }; |
||
| 9911 | |||
| 9912 | var moveDown = function (caret, amount) { |
||
| 9913 | return { |
||
| 9914 | left: caret.left, |
||
| 9915 | top: caret.top + amount, |
||
| 9916 | right: caret.right, |
||
| 9917 | bottom: caret.bottom + amount |
||
| 9918 | }; |
||
| 9919 | }; |
||
| 9920 | var moveUp = function (caret, amount) { |
||
| 9921 | return { |
||
| 9922 | left: caret.left, |
||
| 9923 | top: caret.top - amount, |
||
| 9924 | right: caret.right, |
||
| 9925 | bottom: caret.bottom - amount |
||
| 9926 | }; |
||
| 9927 | }; |
||
| 9928 | var translate = function (caret, xDelta, yDelta) { |
||
| 9929 | return { |
||
| 9930 | left: caret.left + xDelta, |
||
| 9931 | top: caret.top + yDelta, |
||
| 9932 | right: caret.right + xDelta, |
||
| 9933 | bottom: caret.bottom + yDelta |
||
| 9934 | }; |
||
| 9935 | }; |
||
| 637 | daniel-mar | 9936 | var getTop = function (caret) { |
| 597 | daniel-mar | 9937 | return caret.top; |
| 9938 | }; |
||
| 9939 | var getBottom = function (caret) { |
||
| 9940 | return caret.bottom; |
||
| 9941 | }; |
||
| 9942 | |||
| 9943 | var getPartialBox = function (bridge, element, offset) { |
||
| 9944 | if (offset >= 0 && offset < getEnd(element)) { |
||
| 9945 | return bridge.getRangedRect(element, offset, element, offset + 1); |
||
| 9946 | } else if (offset > 0) { |
||
| 9947 | return bridge.getRangedRect(element, offset - 1, element, offset); |
||
| 9948 | } |
||
| 9949 | return Optional.none(); |
||
| 9950 | }; |
||
| 9951 | var toCaret = function (rect) { |
||
| 9952 | return { |
||
| 9953 | left: rect.left, |
||
| 9954 | top: rect.top, |
||
| 9955 | right: rect.right, |
||
| 9956 | bottom: rect.bottom |
||
| 9957 | }; |
||
| 9958 | }; |
||
| 9959 | var getElemBox = function (bridge, element) { |
||
| 9960 | return Optional.some(bridge.getRect(element)); |
||
| 9961 | }; |
||
| 9962 | var getBoxAt = function (bridge, element, offset) { |
||
| 9963 | if (isElement(element)) { |
||
| 9964 | return getElemBox(bridge, element).map(toCaret); |
||
| 9965 | } else if (isText(element)) { |
||
| 9966 | return getPartialBox(bridge, element, offset).map(toCaret); |
||
| 9967 | } else { |
||
| 9968 | return Optional.none(); |
||
| 9969 | } |
||
| 9970 | }; |
||
| 9971 | var getEntireBox = function (bridge, element) { |
||
| 9972 | if (isElement(element)) { |
||
| 9973 | return getElemBox(bridge, element).map(toCaret); |
||
| 9974 | } else if (isText(element)) { |
||
| 9975 | return bridge.getRangedRect(element, 0, element, getEnd(element)).map(toCaret); |
||
| 9976 | } else { |
||
| 9977 | return Optional.none(); |
||
| 9978 | } |
||
| 9979 | }; |
||
| 9980 | |||
| 9981 | var JUMP_SIZE = 5; |
||
| 9982 | var NUM_RETRIES = 100; |
||
| 637 | daniel-mar | 9983 | var adt = Adt.generate([ |
| 597 | daniel-mar | 9984 | { none: [] }, |
| 9985 | { retry: ['caret'] } |
||
| 9986 | ]); |
||
| 9987 | var isOutside = function (caret, box) { |
||
| 9988 | return caret.left < box.left || Math.abs(box.right - caret.left) < 1 || caret.left > box.right; |
||
| 9989 | }; |
||
| 9990 | var inOutsideBlock = function (bridge, element, caret) { |
||
| 637 | daniel-mar | 9991 | return closest$2(element, isBlock).fold(never, function (cell) { |
| 597 | daniel-mar | 9992 | return getEntireBox(bridge, cell).exists(function (box) { |
| 9993 | return isOutside(caret, box); |
||
| 9994 | }); |
||
| 9995 | }); |
||
| 9996 | }; |
||
| 9997 | var adjustDown = function (bridge, element, guessBox, original, caret) { |
||
| 9998 | var lowerCaret = moveDown(caret, JUMP_SIZE); |
||
| 9999 | if (Math.abs(guessBox.bottom - original.bottom) < 1) { |
||
| 637 | daniel-mar | 10000 | return adt.retry(lowerCaret); |
| 597 | daniel-mar | 10001 | } else if (guessBox.top > caret.bottom) { |
| 637 | daniel-mar | 10002 | return adt.retry(lowerCaret); |
| 597 | daniel-mar | 10003 | } else if (guessBox.top === caret.bottom) { |
| 637 | daniel-mar | 10004 | return adt.retry(moveDown(caret, 1)); |
| 597 | daniel-mar | 10005 | } else { |
| 637 | daniel-mar | 10006 | return inOutsideBlock(bridge, element, caret) ? adt.retry(translate(lowerCaret, JUMP_SIZE, 0)) : adt.none(); |
| 597 | daniel-mar | 10007 | } |
| 10008 | }; |
||
| 10009 | var adjustUp = function (bridge, element, guessBox, original, caret) { |
||
| 10010 | var higherCaret = moveUp(caret, JUMP_SIZE); |
||
| 10011 | if (Math.abs(guessBox.top - original.top) < 1) { |
||
| 637 | daniel-mar | 10012 | return adt.retry(higherCaret); |
| 597 | daniel-mar | 10013 | } else if (guessBox.bottom < caret.top) { |
| 637 | daniel-mar | 10014 | return adt.retry(higherCaret); |
| 597 | daniel-mar | 10015 | } else if (guessBox.bottom === caret.top) { |
| 637 | daniel-mar | 10016 | return adt.retry(moveUp(caret, 1)); |
| 597 | daniel-mar | 10017 | } else { |
| 637 | daniel-mar | 10018 | return inOutsideBlock(bridge, element, caret) ? adt.retry(translate(higherCaret, JUMP_SIZE, 0)) : adt.none(); |
| 597 | daniel-mar | 10019 | } |
| 10020 | }; |
||
| 10021 | var upMovement = { |
||
| 637 | daniel-mar | 10022 | point: getTop, |
| 597 | daniel-mar | 10023 | adjuster: adjustUp, |
| 10024 | move: moveUp, |
||
| 637 | daniel-mar | 10025 | gather: before |
| 597 | daniel-mar | 10026 | }; |
| 10027 | var downMovement = { |
||
| 10028 | point: getBottom, |
||
| 10029 | adjuster: adjustDown, |
||
| 10030 | move: moveDown, |
||
| 637 | daniel-mar | 10031 | gather: after |
| 597 | daniel-mar | 10032 | }; |
| 10033 | var isAtTable = function (bridge, x, y) { |
||
| 10034 | return bridge.elementFromPoint(x, y).filter(function (elm) { |
||
| 10035 | return name(elm) === 'table'; |
||
| 10036 | }).isSome(); |
||
| 10037 | }; |
||
| 10038 | var adjustForTable = function (bridge, movement, original, caret, numRetries) { |
||
| 10039 | return adjustTil(bridge, movement, original, movement.move(caret, JUMP_SIZE), numRetries); |
||
| 10040 | }; |
||
| 10041 | var adjustTil = function (bridge, movement, original, caret, numRetries) { |
||
| 10042 | if (numRetries === 0) { |
||
| 10043 | return Optional.some(caret); |
||
| 10044 | } |
||
| 10045 | if (isAtTable(bridge, caret.left, movement.point(caret))) { |
||
| 10046 | return adjustForTable(bridge, movement, original, caret, numRetries - 1); |
||
| 10047 | } |
||
| 10048 | return bridge.situsFromPoint(caret.left, movement.point(caret)).bind(function (guess) { |
||
| 10049 | return guess.start.fold(Optional.none, function (element) { |
||
| 10050 | return getEntireBox(bridge, element).bind(function (guessBox) { |
||
| 10051 | return movement.adjuster(bridge, element, guessBox, original, caret).fold(Optional.none, function (newCaret) { |
||
| 10052 | return adjustTil(bridge, movement, original, newCaret, numRetries - 1); |
||
| 10053 | }); |
||
| 10054 | }).orThunk(function () { |
||
| 10055 | return Optional.some(caret); |
||
| 10056 | }); |
||
| 10057 | }, Optional.none); |
||
| 10058 | }); |
||
| 10059 | }; |
||
| 10060 | var ieTryDown = function (bridge, caret) { |
||
| 10061 | return bridge.situsFromPoint(caret.left, caret.bottom + JUMP_SIZE); |
||
| 10062 | }; |
||
| 10063 | var ieTryUp = function (bridge, caret) { |
||
| 10064 | return bridge.situsFromPoint(caret.left, caret.top - JUMP_SIZE); |
||
| 10065 | }; |
||
| 10066 | var checkScroll = function (movement, adjusted, bridge) { |
||
| 10067 | if (movement.point(adjusted) > bridge.getInnerHeight()) { |
||
| 10068 | return Optional.some(movement.point(adjusted) - bridge.getInnerHeight()); |
||
| 10069 | } else if (movement.point(adjusted) < 0) { |
||
| 10070 | return Optional.some(-movement.point(adjusted)); |
||
| 10071 | } else { |
||
| 10072 | return Optional.none(); |
||
| 10073 | } |
||
| 10074 | }; |
||
| 10075 | var retry = function (movement, bridge, caret) { |
||
| 10076 | var moved = movement.move(caret, JUMP_SIZE); |
||
| 10077 | var adjusted = adjustTil(bridge, movement, caret, moved, NUM_RETRIES).getOr(moved); |
||
| 10078 | return checkScroll(movement, adjusted, bridge).fold(function () { |
||
| 10079 | return bridge.situsFromPoint(adjusted.left, movement.point(adjusted)); |
||
| 10080 | }, function (delta) { |
||
| 10081 | bridge.scrollBy(0, delta); |
||
| 10082 | return bridge.situsFromPoint(adjusted.left, movement.point(adjusted) - delta); |
||
| 10083 | }); |
||
| 10084 | }; |
||
| 10085 | var Retries = { |
||
| 10086 | tryUp: curry(retry, upMovement), |
||
| 10087 | tryDown: curry(retry, downMovement), |
||
| 10088 | ieTryUp: ieTryUp, |
||
| 10089 | ieTryDown: ieTryDown, |
||
| 10090 | getJumpSize: constant(JUMP_SIZE) |
||
| 10091 | }; |
||
| 10092 | |||
| 10093 | var MAX_RETRIES = 20; |
||
| 10094 | var findSpot = function (bridge, isRoot, direction) { |
||
| 10095 | return bridge.getSelection().bind(function (sel) { |
||
| 10096 | return tryBr(isRoot, sel.finish, sel.foffset, direction).fold(function () { |
||
| 10097 | return Optional.some(point(sel.finish, sel.foffset)); |
||
| 10098 | }, function (brNeighbour) { |
||
| 10099 | var range = bridge.fromSitus(brNeighbour); |
||
| 10100 | var analysis = BeforeAfter.verify(bridge, sel.finish, sel.foffset, range.finish, range.foffset, direction.failure, isRoot); |
||
| 10101 | return process(analysis); |
||
| 10102 | }); |
||
| 10103 | }); |
||
| 10104 | }; |
||
| 637 | daniel-mar | 10105 | var scan = function (bridge, isRoot, element, offset, direction, numRetries) { |
| 597 | daniel-mar | 10106 | if (numRetries === 0) { |
| 10107 | return Optional.none(); |
||
| 10108 | } |
||
| 10109 | return tryCursor(bridge, isRoot, element, offset, direction).bind(function (situs) { |
||
| 10110 | var range = bridge.fromSitus(situs); |
||
| 10111 | var analysis = BeforeAfter.verify(bridge, element, offset, range.finish, range.foffset, direction.failure, isRoot); |
||
| 10112 | return BeforeAfter.cata(analysis, function () { |
||
| 10113 | return Optional.none(); |
||
| 10114 | }, function () { |
||
| 10115 | return Optional.some(situs); |
||
| 10116 | }, function (cell) { |
||
| 10117 | if (eq$1(element, cell) && offset === 0) { |
||
| 10118 | return tryAgain(bridge, element, offset, moveUp, direction); |
||
| 10119 | } else { |
||
| 637 | daniel-mar | 10120 | return scan(bridge, isRoot, cell, 0, direction, numRetries - 1); |
| 597 | daniel-mar | 10121 | } |
| 10122 | }, function (cell) { |
||
| 10123 | if (eq$1(element, cell) && offset === getEnd(cell)) { |
||
| 10124 | return tryAgain(bridge, element, offset, moveDown, direction); |
||
| 10125 | } else { |
||
| 637 | daniel-mar | 10126 | return scan(bridge, isRoot, cell, getEnd(cell), direction, numRetries - 1); |
| 597 | daniel-mar | 10127 | } |
| 10128 | }); |
||
| 10129 | }); |
||
| 10130 | }; |
||
| 10131 | var tryAgain = function (bridge, element, offset, move, direction) { |
||
| 10132 | return getBoxAt(bridge, element, offset).bind(function (box) { |
||
| 10133 | return tryAt(bridge, direction, move(box, Retries.getJumpSize())); |
||
| 10134 | }); |
||
| 10135 | }; |
||
| 10136 | var tryAt = function (bridge, direction, box) { |
||
| 10137 | var browser = detect$3().browser; |
||
| 10138 | if (browser.isChrome() || browser.isSafari() || browser.isFirefox() || browser.isEdge()) { |
||
| 10139 | return direction.otherRetry(bridge, box); |
||
| 10140 | } else if (browser.isIE()) { |
||
| 10141 | return direction.ieRetry(bridge, box); |
||
| 10142 | } else { |
||
| 10143 | return Optional.none(); |
||
| 10144 | } |
||
| 10145 | }; |
||
| 10146 | var tryCursor = function (bridge, isRoot, element, offset, direction) { |
||
| 10147 | return getBoxAt(bridge, element, offset).bind(function (box) { |
||
| 10148 | return tryAt(bridge, direction, box); |
||
| 10149 | }); |
||
| 10150 | }; |
||
| 637 | daniel-mar | 10151 | var handle = function (bridge, isRoot, direction) { |
| 597 | daniel-mar | 10152 | return findSpot(bridge, isRoot, direction).bind(function (spot) { |
| 637 | daniel-mar | 10153 | return scan(bridge, isRoot, spot.element, spot.offset, direction, MAX_RETRIES).map(bridge.fromSitus); |
| 597 | daniel-mar | 10154 | }); |
| 10155 | }; |
||
| 10156 | |||
| 10157 | var inSameTable = function (elem, table) { |
||
| 637 | daniel-mar | 10158 | return ancestor(elem, function (e) { |
| 597 | daniel-mar | 10159 | return parent(e).exists(function (p) { |
| 10160 | return eq$1(p, table); |
||
| 10161 | }); |
||
| 10162 | }); |
||
| 10163 | }; |
||
| 10164 | var simulate = function (bridge, isRoot, direction, initial, anchor) { |
||
| 10165 | return closest$1(initial, 'td,th', isRoot).bind(function (start) { |
||
| 10166 | return closest$1(start, 'table', isRoot).bind(function (table) { |
||
| 10167 | if (!inSameTable(anchor, table)) { |
||
| 10168 | return Optional.none(); |
||
| 10169 | } |
||
| 637 | daniel-mar | 10170 | return handle(bridge, isRoot, direction).bind(function (range) { |
| 597 | daniel-mar | 10171 | return closest$1(range.finish, 'td,th', isRoot).map(function (finish) { |
| 10172 | return { |
||
| 10173 | start: start, |
||
| 10174 | finish: finish, |
||
| 10175 | range: range |
||
| 10176 | }; |
||
| 10177 | }); |
||
| 10178 | }); |
||
| 10179 | }); |
||
| 10180 | }); |
||
| 10181 | }; |
||
| 10182 | var navigate = function (bridge, isRoot, direction, initial, anchor, precheck) { |
||
| 10183 | if (detect$3().browser.isIE()) { |
||
| 10184 | return Optional.none(); |
||
| 10185 | } else { |
||
| 10186 | return precheck(initial, isRoot).orThunk(function () { |
||
| 10187 | return simulate(bridge, isRoot, direction, initial, anchor).map(function (info) { |
||
| 10188 | var range = info.range; |
||
| 10189 | return Response.create(Optional.some(makeSitus(range.start, range.soffset, range.finish, range.foffset)), true); |
||
| 10190 | }); |
||
| 10191 | }); |
||
| 10192 | } |
||
| 10193 | }; |
||
| 10194 | var firstUpCheck = function (initial, isRoot) { |
||
| 10195 | return closest$1(initial, 'tr', isRoot).bind(function (startRow) { |
||
| 10196 | return closest$1(startRow, 'table', isRoot).bind(function (table) { |
||
| 637 | daniel-mar | 10197 | var rows = descendants(table, 'tr'); |
| 597 | daniel-mar | 10198 | if (eq$1(startRow, rows[0])) { |
| 637 | daniel-mar | 10199 | return seekLeft(table, function (element) { |
| 597 | daniel-mar | 10200 | return last$1(element).isSome(); |
| 10201 | }, isRoot).map(function (last) { |
||
| 10202 | var lastOffset = getEnd(last); |
||
| 10203 | return Response.create(Optional.some(makeSitus(last, lastOffset, last, lastOffset)), true); |
||
| 10204 | }); |
||
| 10205 | } else { |
||
| 10206 | return Optional.none(); |
||
| 10207 | } |
||
| 10208 | }); |
||
| 10209 | }); |
||
| 10210 | }; |
||
| 10211 | var lastDownCheck = function (initial, isRoot) { |
||
| 10212 | return closest$1(initial, 'tr', isRoot).bind(function (startRow) { |
||
| 10213 | return closest$1(startRow, 'table', isRoot).bind(function (table) { |
||
| 637 | daniel-mar | 10214 | var rows = descendants(table, 'tr'); |
| 597 | daniel-mar | 10215 | if (eq$1(startRow, rows[rows.length - 1])) { |
| 637 | daniel-mar | 10216 | return seekRight(table, function (element) { |
| 597 | daniel-mar | 10217 | return first(element).isSome(); |
| 10218 | }, isRoot).map(function (first) { |
||
| 10219 | return Response.create(Optional.some(makeSitus(first, 0, first, 0)), true); |
||
| 10220 | }); |
||
| 10221 | } else { |
||
| 10222 | return Optional.none(); |
||
| 10223 | } |
||
| 10224 | }); |
||
| 10225 | }); |
||
| 10226 | }; |
||
| 10227 | var select = function (bridge, container, isRoot, direction, initial, anchor, selectRange) { |
||
| 10228 | return simulate(bridge, isRoot, direction, initial, anchor).bind(function (info) { |
||
| 637 | daniel-mar | 10229 | return detect(container, isRoot, info.start, info.finish, selectRange); |
| 597 | daniel-mar | 10230 | }); |
| 10231 | }; |
||
| 10232 | |||
| 10233 | var findCell = function (target, isRoot) { |
||
| 10234 | return closest$1(target, 'td,th', isRoot); |
||
| 10235 | }; |
||
| 10236 | var MouseSelection = function (bridge, container, isRoot, annotations) { |
||
| 637 | daniel-mar | 10237 | var cursor = value(); |
| 597 | daniel-mar | 10238 | var clearstate = cursor.clear; |
| 10239 | var applySelection = function (event) { |
||
| 10240 | cursor.on(function (start) { |
||
| 10241 | annotations.clearBeforeUpdate(container); |
||
| 10242 | findCell(event.target, isRoot).each(function (finish) { |
||
| 10243 | identify(start, finish, isRoot).each(function (cellSel) { |
||
| 10244 | var boxes = cellSel.boxes.getOr([]); |
||
| 637 | daniel-mar | 10245 | if (boxes.length === 1) { |
| 10246 | var singleCell = boxes[0]; |
||
| 10247 | var isNonEditableCell = getRaw(singleCell) === 'false'; |
||
| 10248 | var isCellClosestContentEditable = is(closest(event.target), singleCell, eq$1); |
||
| 10249 | if (isNonEditableCell && isCellClosestContentEditable) { |
||
| 10250 | annotations.selectRange(container, boxes, singleCell, singleCell); |
||
| 10251 | bridge.selectContents(singleCell); |
||
| 10252 | } |
||
| 10253 | } else if (boxes.length > 1) { |
||
| 597 | daniel-mar | 10254 | annotations.selectRange(container, boxes, cellSel.start, cellSel.finish); |
| 10255 | bridge.selectContents(finish); |
||
| 10256 | } |
||
| 10257 | }); |
||
| 10258 | }); |
||
| 10259 | }); |
||
| 10260 | }; |
||
| 10261 | var mousedown = function (event) { |
||
| 10262 | annotations.clear(container); |
||
| 10263 | findCell(event.target, isRoot).each(cursor.set); |
||
| 10264 | }; |
||
| 10265 | var mouseover = function (event) { |
||
| 10266 | applySelection(event); |
||
| 10267 | }; |
||
| 10268 | var mouseup = function (event) { |
||
| 10269 | applySelection(event); |
||
| 10270 | clearstate(); |
||
| 10271 | }; |
||
| 10272 | return { |
||
| 10273 | clearstate: clearstate, |
||
| 10274 | mousedown: mousedown, |
||
| 10275 | mouseover: mouseover, |
||
| 10276 | mouseup: mouseup |
||
| 10277 | }; |
||
| 10278 | }; |
||
| 10279 | |||
| 10280 | var down = { |
||
| 10281 | traverse: nextSibling, |
||
| 637 | daniel-mar | 10282 | gather: after, |
| 597 | daniel-mar | 10283 | relative: Situ.before, |
| 10284 | otherRetry: Retries.tryDown, |
||
| 10285 | ieRetry: Retries.ieTryDown, |
||
| 10286 | failure: BeforeAfter.failedDown |
||
| 10287 | }; |
||
| 10288 | var up = { |
||
| 10289 | traverse: prevSibling, |
||
| 637 | daniel-mar | 10290 | gather: before, |
| 597 | daniel-mar | 10291 | relative: Situ.before, |
| 10292 | otherRetry: Retries.tryUp, |
||
| 10293 | ieRetry: Retries.ieTryUp, |
||
| 10294 | failure: BeforeAfter.failedUp |
||
| 10295 | }; |
||
| 10296 | |||
| 10297 | var isKey = function (key) { |
||
| 10298 | return function (keycode) { |
||
| 10299 | return keycode === key; |
||
| 10300 | }; |
||
| 10301 | }; |
||
| 10302 | var isUp = isKey(38); |
||
| 10303 | var isDown = isKey(40); |
||
| 10304 | var isNavigation = function (keycode) { |
||
| 10305 | return keycode >= 37 && keycode <= 40; |
||
| 10306 | }; |
||
| 637 | daniel-mar | 10307 | var ltr = { |
| 597 | daniel-mar | 10308 | isBackward: isKey(37), |
| 10309 | isForward: isKey(39) |
||
| 10310 | }; |
||
| 637 | daniel-mar | 10311 | var rtl = { |
| 597 | daniel-mar | 10312 | isBackward: isKey(39), |
| 10313 | isForward: isKey(37) |
||
| 10314 | }; |
||
| 10315 | |||
| 637 | daniel-mar | 10316 | var get = function (_DOC) { |
| 597 | daniel-mar | 10317 | var doc = _DOC !== undefined ? _DOC.dom : document; |
| 10318 | var x = doc.body.scrollLeft || doc.documentElement.scrollLeft; |
||
| 10319 | var y = doc.body.scrollTop || doc.documentElement.scrollTop; |
||
| 10320 | return SugarPosition(x, y); |
||
| 10321 | }; |
||
| 10322 | var by = function (x, y, _DOC) { |
||
| 10323 | var doc = _DOC !== undefined ? _DOC.dom : document; |
||
| 10324 | var win = doc.defaultView; |
||
| 10325 | if (win) { |
||
| 10326 | win.scrollBy(x, y); |
||
| 10327 | } |
||
| 10328 | }; |
||
| 10329 | |||
| 10330 | var WindowBridge = function (win) { |
||
| 10331 | var elementFromPoint = function (x, y) { |
||
| 10332 | return SugarElement.fromPoint(SugarElement.fromDom(win.document), x, y); |
||
| 10333 | }; |
||
| 10334 | var getRect = function (element) { |
||
| 10335 | return element.dom.getBoundingClientRect(); |
||
| 10336 | }; |
||
| 10337 | var getRangedRect = function (start, soffset, finish, foffset) { |
||
| 10338 | var sel = SimSelection.exact(start, soffset, finish, foffset); |
||
| 637 | daniel-mar | 10339 | return getFirstRect(win, sel); |
| 597 | daniel-mar | 10340 | }; |
| 10341 | var getSelection = function () { |
||
| 637 | daniel-mar | 10342 | return get$1(win).map(function (exactAdt) { |
| 597 | daniel-mar | 10343 | return convertToRange(win, exactAdt); |
| 10344 | }); |
||
| 10345 | }; |
||
| 10346 | var fromSitus = function (situs) { |
||
| 10347 | var relative = SimSelection.relative(situs.start, situs.finish); |
||
| 10348 | return convertToRange(win, relative); |
||
| 10349 | }; |
||
| 10350 | var situsFromPoint = function (x, y) { |
||
| 10351 | return getAtPoint(win, x, y).map(function (exact) { |
||
| 10352 | return Situs.create(exact.start, exact.soffset, exact.finish, exact.foffset); |
||
| 10353 | }); |
||
| 10354 | }; |
||
| 10355 | var clearSelection = function () { |
||
| 10356 | clear(win); |
||
| 10357 | }; |
||
| 10358 | var collapseSelection = function (toStart) { |
||
| 10359 | if (toStart === void 0) { |
||
| 10360 | toStart = false; |
||
| 10361 | } |
||
| 637 | daniel-mar | 10362 | get$1(win).each(function (sel) { |
| 597 | daniel-mar | 10363 | return sel.fold(function (rng) { |
| 10364 | return rng.collapse(toStart); |
||
| 10365 | }, function (startSitu, finishSitu) { |
||
| 10366 | var situ = toStart ? startSitu : finishSitu; |
||
| 10367 | setRelative(win, situ, situ); |
||
| 10368 | }, function (start, soffset, finish, foffset) { |
||
| 10369 | var node = toStart ? start : finish; |
||
| 10370 | var offset = toStart ? soffset : foffset; |
||
| 10371 | setExact(win, node, offset, node, offset); |
||
| 10372 | }); |
||
| 10373 | }); |
||
| 10374 | }; |
||
| 637 | daniel-mar | 10375 | var selectNode = function (element) { |
| 10376 | setToElement(win, element, false); |
||
| 10377 | }; |
||
| 597 | daniel-mar | 10378 | var selectContents = function (element) { |
| 10379 | setToElement(win, element); |
||
| 10380 | }; |
||
| 10381 | var setSelection = function (sel) { |
||
| 10382 | setExact(win, sel.start, sel.soffset, sel.finish, sel.foffset); |
||
| 10383 | }; |
||
| 10384 | var setRelativeSelection = function (start, finish) { |
||
| 10385 | setRelative(win, start, finish); |
||
| 10386 | }; |
||
| 10387 | var getInnerHeight = function () { |
||
| 10388 | return win.innerHeight; |
||
| 10389 | }; |
||
| 10390 | var getScrollY = function () { |
||
| 637 | daniel-mar | 10391 | var pos = get(SugarElement.fromDom(win.document)); |
| 597 | daniel-mar | 10392 | return pos.top; |
| 10393 | }; |
||
| 10394 | var scrollBy = function (x, y) { |
||
| 10395 | by(x, y, SugarElement.fromDom(win.document)); |
||
| 10396 | }; |
||
| 10397 | return { |
||
| 10398 | elementFromPoint: elementFromPoint, |
||
| 10399 | getRect: getRect, |
||
| 10400 | getRangedRect: getRangedRect, |
||
| 10401 | getSelection: getSelection, |
||
| 10402 | fromSitus: fromSitus, |
||
| 10403 | situsFromPoint: situsFromPoint, |
||
| 10404 | clearSelection: clearSelection, |
||
| 10405 | collapseSelection: collapseSelection, |
||
| 10406 | setSelection: setSelection, |
||
| 10407 | setRelativeSelection: setRelativeSelection, |
||
| 637 | daniel-mar | 10408 | selectNode: selectNode, |
| 597 | daniel-mar | 10409 | selectContents: selectContents, |
| 10410 | getInnerHeight: getInnerHeight, |
||
| 10411 | getScrollY: getScrollY, |
||
| 10412 | scrollBy: scrollBy |
||
| 10413 | }; |
||
| 10414 | }; |
||
| 10415 | |||
| 10416 | var rc = function (rows, cols) { |
||
| 10417 | return { |
||
| 10418 | rows: rows, |
||
| 10419 | cols: cols |
||
| 10420 | }; |
||
| 10421 | }; |
||
| 10422 | var mouse = function (win, container, isRoot, annotations) { |
||
| 10423 | var bridge = WindowBridge(win); |
||
| 10424 | var handlers = MouseSelection(bridge, container, isRoot, annotations); |
||
| 10425 | return { |
||
| 10426 | clearstate: handlers.clearstate, |
||
| 10427 | mousedown: handlers.mousedown, |
||
| 10428 | mouseover: handlers.mouseover, |
||
| 10429 | mouseup: handlers.mouseup |
||
| 10430 | }; |
||
| 10431 | }; |
||
| 10432 | var keyboard = function (win, container, isRoot, annotations) { |
||
| 10433 | var bridge = WindowBridge(win); |
||
| 10434 | var clearToNavigate = function () { |
||
| 10435 | annotations.clear(container); |
||
| 10436 | return Optional.none(); |
||
| 10437 | }; |
||
| 10438 | var keydown = function (event, start, soffset, finish, foffset, direction) { |
||
| 10439 | var realEvent = event.raw; |
||
| 10440 | var keycode = realEvent.which; |
||
| 10441 | var shiftKey = realEvent.shiftKey === true; |
||
| 637 | daniel-mar | 10442 | var handler = retrieve$1(container, annotations.selectedSelector).fold(function () { |
| 679 | daniel-mar | 10443 | if (isNavigation(keycode) && !shiftKey) { |
| 10444 | annotations.clearBeforeUpdate(container); |
||
| 10445 | } |
||
| 597 | daniel-mar | 10446 | if (isDown(keycode) && shiftKey) { |
| 10447 | return curry(select, bridge, container, isRoot, down, finish, start, annotations.selectRange); |
||
| 10448 | } else if (isUp(keycode) && shiftKey) { |
||
| 10449 | return curry(select, bridge, container, isRoot, up, finish, start, annotations.selectRange); |
||
| 10450 | } else if (isDown(keycode)) { |
||
| 10451 | return curry(navigate, bridge, isRoot, down, finish, start, lastDownCheck); |
||
| 10452 | } else if (isUp(keycode)) { |
||
| 10453 | return curry(navigate, bridge, isRoot, up, finish, start, firstUpCheck); |
||
| 10454 | } else { |
||
| 10455 | return Optional.none; |
||
| 10456 | } |
||
| 10457 | }, function (selected) { |
||
| 10458 | var update$1 = function (attempts) { |
||
| 10459 | return function () { |
||
| 10460 | var navigation = findMap(attempts, function (delta) { |
||
| 10461 | return update(delta.rows, delta.cols, container, selected, annotations); |
||
| 10462 | }); |
||
| 10463 | return navigation.fold(function () { |
||
| 10464 | return getEdges(container, annotations.firstSelectedSelector, annotations.lastSelectedSelector).map(function (edges) { |
||
| 10465 | var relative = isDown(keycode) || direction.isForward(keycode) ? Situ.after : Situ.before; |
||
| 10466 | bridge.setRelativeSelection(Situ.on(edges.first, 0), relative(edges.table)); |
||
| 10467 | annotations.clear(container); |
||
| 10468 | return Response.create(Optional.none(), true); |
||
| 10469 | }); |
||
| 10470 | }, function (_) { |
||
| 10471 | return Optional.some(Response.create(Optional.none(), true)); |
||
| 10472 | }); |
||
| 10473 | }; |
||
| 10474 | }; |
||
| 10475 | if (isDown(keycode) && shiftKey) { |
||
| 10476 | return update$1([rc(+1, 0)]); |
||
| 10477 | } else if (isUp(keycode) && shiftKey) { |
||
| 10478 | return update$1([rc(-1, 0)]); |
||
| 10479 | } else if (direction.isBackward(keycode) && shiftKey) { |
||
| 10480 | return update$1([ |
||
| 10481 | rc(0, -1), |
||
| 10482 | rc(-1, 0) |
||
| 10483 | ]); |
||
| 10484 | } else if (direction.isForward(keycode) && shiftKey) { |
||
| 10485 | return update$1([ |
||
| 10486 | rc(0, +1), |
||
| 10487 | rc(+1, 0) |
||
| 10488 | ]); |
||
| 679 | daniel-mar | 10489 | } else if (isNavigation(keycode) && !shiftKey) { |
| 597 | daniel-mar | 10490 | return clearToNavigate; |
| 10491 | } else { |
||
| 10492 | return Optional.none; |
||
| 10493 | } |
||
| 10494 | }); |
||
| 10495 | return handler(); |
||
| 10496 | }; |
||
| 10497 | var keyup = function (event, start, soffset, finish, foffset) { |
||
| 637 | daniel-mar | 10498 | return retrieve$1(container, annotations.selectedSelector).fold(function () { |
| 597 | daniel-mar | 10499 | var realEvent = event.raw; |
| 10500 | var keycode = realEvent.which; |
||
| 10501 | var shiftKey = realEvent.shiftKey === true; |
||
| 679 | daniel-mar | 10502 | if (!shiftKey) { |
| 597 | daniel-mar | 10503 | return Optional.none(); |
| 10504 | } |
||
| 10505 | if (isNavigation(keycode)) { |
||
| 10506 | return sync(container, isRoot, start, soffset, finish, foffset, annotations.selectRange); |
||
| 10507 | } else { |
||
| 10508 | return Optional.none(); |
||
| 10509 | } |
||
| 10510 | }, Optional.none); |
||
| 10511 | }; |
||
| 10512 | return { |
||
| 10513 | keydown: keydown, |
||
| 10514 | keyup: keyup |
||
| 10515 | }; |
||
| 10516 | }; |
||
| 10517 | var external = function (win, container, isRoot, annotations) { |
||
| 10518 | var bridge = WindowBridge(win); |
||
| 10519 | return function (start, finish) { |
||
| 10520 | annotations.clearBeforeUpdate(container); |
||
| 10521 | identify(start, finish, isRoot).each(function (cellSel) { |
||
| 10522 | var boxes = cellSel.boxes.getOr([]); |
||
| 10523 | annotations.selectRange(container, boxes, cellSel.start, cellSel.finish); |
||
| 10524 | bridge.selectContents(finish); |
||
| 10525 | bridge.collapseSelection(); |
||
| 10526 | }); |
||
| 10527 | }; |
||
| 10528 | }; |
||
| 10529 | |||
| 637 | daniel-mar | 10530 | var remove = function (element, classes) { |
| 10531 | each$2(classes, function (x) { |
||
| 10532 | remove$2(element, x); |
||
| 597 | daniel-mar | 10533 | }); |
| 10534 | }; |
||
| 10535 | |||
| 10536 | var addClass = function (clazz) { |
||
| 10537 | return function (element) { |
||
| 637 | daniel-mar | 10538 | add(element, clazz); |
| 597 | daniel-mar | 10539 | }; |
| 10540 | }; |
||
| 10541 | var removeClasses = function (classes) { |
||
| 10542 | return function (element) { |
||
| 637 | daniel-mar | 10543 | remove(element, classes); |
| 597 | daniel-mar | 10544 | }; |
| 10545 | }; |
||
| 10546 | |||
| 10547 | var byClass = function (ephemera) { |
||
| 10548 | var addSelectionClass = addClass(ephemera.selected); |
||
| 10549 | var removeSelectionClasses = removeClasses([ |
||
| 10550 | ephemera.selected, |
||
| 10551 | ephemera.lastSelected, |
||
| 10552 | ephemera.firstSelected |
||
| 10553 | ]); |
||
| 10554 | var clear = function (container) { |
||
| 637 | daniel-mar | 10555 | var sels = descendants(container, ephemera.selectedSelector); |
| 10556 | each$2(sels, removeSelectionClasses); |
||
| 597 | daniel-mar | 10557 | }; |
| 10558 | var selectRange = function (container, cells, start, finish) { |
||
| 10559 | clear(container); |
||
| 637 | daniel-mar | 10560 | each$2(cells, addSelectionClass); |
| 10561 | add(start, ephemera.firstSelected); |
||
| 10562 | add(finish, ephemera.lastSelected); |
||
| 597 | daniel-mar | 10563 | }; |
| 10564 | return { |
||
| 10565 | clearBeforeUpdate: clear, |
||
| 10566 | clear: clear, |
||
| 10567 | selectRange: selectRange, |
||
| 10568 | selectedSelector: ephemera.selectedSelector, |
||
| 10569 | firstSelectedSelector: ephemera.firstSelectedSelector, |
||
| 10570 | lastSelectedSelector: ephemera.lastSelectedSelector |
||
| 10571 | }; |
||
| 10572 | }; |
||
| 10573 | var byAttr = function (ephemera, onSelection, onClear) { |
||
| 10574 | var removeSelectionAttributes = function (element) { |
||
| 637 | daniel-mar | 10575 | remove$7(element, ephemera.selected); |
| 10576 | remove$7(element, ephemera.firstSelected); |
||
| 10577 | remove$7(element, ephemera.lastSelected); |
||
| 597 | daniel-mar | 10578 | }; |
| 10579 | var addSelectionAttribute = function (element) { |
||
| 637 | daniel-mar | 10580 | set$2(element, ephemera.selected, '1'); |
| 597 | daniel-mar | 10581 | }; |
| 10582 | var clear = function (container) { |
||
| 10583 | clearBeforeUpdate(container); |
||
| 10584 | onClear(); |
||
| 10585 | }; |
||
| 10586 | var clearBeforeUpdate = function (container) { |
||
| 679 | daniel-mar | 10587 | var sels = descendants(container, ephemera.selectedSelector + ',' + ephemera.firstSelectedSelector + ',' + ephemera.lastSelectedSelector); |
| 637 | daniel-mar | 10588 | each$2(sels, removeSelectionAttributes); |
| 597 | daniel-mar | 10589 | }; |
| 10590 | var selectRange = function (container, cells, start, finish) { |
||
| 10591 | clear(container); |
||
| 637 | daniel-mar | 10592 | each$2(cells, addSelectionAttribute); |
| 10593 | set$2(start, ephemera.firstSelected, '1'); |
||
| 10594 | set$2(finish, ephemera.lastSelected, '1'); |
||
| 597 | daniel-mar | 10595 | onSelection(cells, start, finish); |
| 10596 | }; |
||
| 10597 | return { |
||
| 10598 | clearBeforeUpdate: clearBeforeUpdate, |
||
| 10599 | clear: clear, |
||
| 10600 | selectRange: selectRange, |
||
| 10601 | selectedSelector: ephemera.selectedSelector, |
||
| 10602 | firstSelectedSelector: ephemera.firstSelectedSelector, |
||
| 10603 | lastSelectedSelector: ephemera.lastSelectedSelector |
||
| 10604 | }; |
||
| 10605 | }; |
||
| 10606 | var SelectionAnnotation = { |
||
| 10607 | byClass: byClass, |
||
| 10608 | byAttr: byAttr |
||
| 10609 | }; |
||
| 10610 | |||
| 637 | daniel-mar | 10611 | var getUpOrLeftCells = function (grid, selectedCells) { |
| 597 | daniel-mar | 10612 | var upGrid = grid.slice(0, selectedCells[selectedCells.length - 1].row + 1); |
| 637 | daniel-mar | 10613 | var upDetails = toDetailList(upGrid); |
| 10614 | return bind$2(upDetails, function (detail) { |
||
| 597 | daniel-mar | 10615 | var slicedCells = detail.cells.slice(0, selectedCells[selectedCells.length - 1].column + 1); |
| 637 | daniel-mar | 10616 | return map$1(slicedCells, function (cell) { |
| 597 | daniel-mar | 10617 | return cell.element; |
| 10618 | }); |
||
| 10619 | }); |
||
| 10620 | }; |
||
| 637 | daniel-mar | 10621 | var getDownOrRightCells = function (grid, selectedCells) { |
| 597 | daniel-mar | 10622 | var downGrid = grid.slice(selectedCells[0].row + selectedCells[0].rowspan - 1, grid.length); |
| 637 | daniel-mar | 10623 | var downDetails = toDetailList(downGrid); |
| 10624 | return bind$2(downDetails, function (detail) { |
||
| 597 | daniel-mar | 10625 | var slicedCells = detail.cells.slice(selectedCells[0].column + selectedCells[0].colspan - 1, detail.cells.length); |
| 637 | daniel-mar | 10626 | return map$1(slicedCells, function (cell) { |
| 597 | daniel-mar | 10627 | return cell.element; |
| 10628 | }); |
||
| 10629 | }); |
||
| 10630 | }; |
||
| 10631 | var getOtherCells = function (table, target, generators) { |
||
| 10632 | var warehouse = Warehouse.fromTable(table); |
||
| 10633 | var details = onCells(warehouse, target); |
||
| 10634 | return details.map(function (selectedCells) { |
||
| 10635 | var grid = toGrid(warehouse, generators, false); |
||
| 637 | daniel-mar | 10636 | var upOrLeftCells = getUpOrLeftCells(grid, selectedCells); |
| 10637 | var downOrRightCells = getDownOrRightCells(grid, selectedCells); |
||
| 597 | daniel-mar | 10638 | return { |
| 10639 | upOrLeftCells: upOrLeftCells, |
||
| 10640 | downOrRightCells: downOrRightCells |
||
| 10641 | }; |
||
| 10642 | }); |
||
| 10643 | }; |
||
| 10644 | |||
| 637 | daniel-mar | 10645 | var global = tinymce.util.Tools.resolve('tinymce.Env'); |
| 10646 | |||
| 597 | daniel-mar | 10647 | var hasInternalTarget = function (e) { |
| 637 | daniel-mar | 10648 | return has(SugarElement.fromDom(e.target), 'ephox-snooker-resizer-bar') === false; |
| 597 | daniel-mar | 10649 | }; |
| 10650 | function CellSelection (editor, lazyResize, selectionTargets) { |
||
| 10651 | var onSelection = function (cells, start, finish) { |
||
| 10652 | selectionTargets.targets().each(function (targets) { |
||
| 10653 | var tableOpt = table(start); |
||
| 10654 | tableOpt.each(function (table) { |
||
| 10655 | var cloneFormats = getCloneElements(editor); |
||
| 10656 | var generators = cellOperations(noop, SugarElement.fromDom(editor.getDoc()), cloneFormats); |
||
| 10657 | var otherCells = getOtherCells(table, targets, generators); |
||
| 10658 | fireTableSelectionChange(editor, cells, start, finish, otherCells); |
||
| 10659 | }); |
||
| 10660 | }); |
||
| 10661 | }; |
||
| 10662 | var onClear = function () { |
||
| 10663 | return fireTableSelectionClear(editor); |
||
| 10664 | }; |
||
| 10665 | var annotations = SelectionAnnotation.byAttr(ephemera, onSelection, onClear); |
||
| 10666 | editor.on('init', function (_e) { |
||
| 10667 | var win = editor.getWin(); |
||
| 637 | daniel-mar | 10668 | var body = getBody(editor); |
| 597 | daniel-mar | 10669 | var isRoot = getIsRoot(editor); |
| 10670 | var syncSelection = function () { |
||
| 10671 | var sel = editor.selection; |
||
| 10672 | var start = SugarElement.fromDom(sel.getStart()); |
||
| 10673 | var end = SugarElement.fromDom(sel.getEnd()); |
||
| 637 | daniel-mar | 10674 | var shared = sharedOne(table, [ |
| 597 | daniel-mar | 10675 | start, |
| 10676 | end |
||
| 10677 | ]); |
||
| 10678 | shared.fold(function () { |
||
| 10679 | return annotations.clear(body); |
||
| 10680 | }, noop); |
||
| 10681 | }; |
||
| 10682 | var mouseHandlers = mouse(win, body, isRoot, annotations); |
||
| 10683 | var keyHandlers = keyboard(win, body, isRoot, annotations); |
||
| 10684 | var external$1 = external(win, body, isRoot, annotations); |
||
| 10685 | var hasShiftKey = function (event) { |
||
| 10686 | return event.raw.shiftKey === true; |
||
| 10687 | }; |
||
| 10688 | editor.on('TableSelectorChange', function (e) { |
||
| 10689 | return external$1(e.start, e.finish); |
||
| 10690 | }); |
||
| 10691 | var handleResponse = function (event, response) { |
||
| 10692 | if (!hasShiftKey(event)) { |
||
| 10693 | return; |
||
| 10694 | } |
||
| 10695 | if (response.kill) { |
||
| 10696 | event.kill(); |
||
| 10697 | } |
||
| 10698 | response.selection.each(function (ns) { |
||
| 10699 | var relative = SimSelection.relative(ns.start, ns.finish); |
||
| 10700 | var rng = asLtrRange(win, relative); |
||
| 10701 | editor.selection.setRng(rng); |
||
| 10702 | }); |
||
| 10703 | }; |
||
| 10704 | var keyup = function (event) { |
||
| 637 | daniel-mar | 10705 | var wrappedEvent = fromRawEvent(event); |
| 597 | daniel-mar | 10706 | if (wrappedEvent.raw.shiftKey && isNavigation(wrappedEvent.raw.which)) { |
| 10707 | var rng = editor.selection.getRng(); |
||
| 10708 | var start = SugarElement.fromDom(rng.startContainer); |
||
| 10709 | var end = SugarElement.fromDom(rng.endContainer); |
||
| 10710 | keyHandlers.keyup(wrappedEvent, start, rng.startOffset, end, rng.endOffset).each(function (response) { |
||
| 10711 | handleResponse(wrappedEvent, response); |
||
| 10712 | }); |
||
| 10713 | } |
||
| 10714 | }; |
||
| 10715 | var keydown = function (event) { |
||
| 637 | daniel-mar | 10716 | var wrappedEvent = fromRawEvent(event); |
| 597 | daniel-mar | 10717 | lazyResize().each(function (resize) { |
| 10718 | return resize.hideBars(); |
||
| 10719 | }); |
||
| 10720 | var rng = editor.selection.getRng(); |
||
| 10721 | var start = SugarElement.fromDom(rng.startContainer); |
||
| 10722 | var end = SugarElement.fromDom(rng.endContainer); |
||
| 637 | daniel-mar | 10723 | var direction = onDirection(ltr, rtl)(SugarElement.fromDom(editor.selection.getStart())); |
| 597 | daniel-mar | 10724 | keyHandlers.keydown(wrappedEvent, start, rng.startOffset, end, rng.endOffset, direction).each(function (response) { |
| 10725 | handleResponse(wrappedEvent, response); |
||
| 10726 | }); |
||
| 10727 | lazyResize().each(function (resize) { |
||
| 10728 | return resize.showBars(); |
||
| 10729 | }); |
||
| 10730 | }; |
||
| 10731 | var isLeftMouse = function (raw) { |
||
| 10732 | return raw.button === 0; |
||
| 10733 | }; |
||
| 10734 | var isLeftButtonPressed = function (raw) { |
||
| 10735 | if (raw.buttons === undefined) { |
||
| 10736 | return true; |
||
| 10737 | } |
||
| 637 | daniel-mar | 10738 | if (global.browser.isEdge() && raw.buttons === 0) { |
| 597 | daniel-mar | 10739 | return true; |
| 10740 | } |
||
| 10741 | return (raw.buttons & 1) !== 0; |
||
| 10742 | }; |
||
| 10743 | var dragStart = function (_e) { |
||
| 10744 | mouseHandlers.clearstate(); |
||
| 10745 | }; |
||
| 10746 | var mouseDown = function (e) { |
||
| 10747 | if (isLeftMouse(e) && hasInternalTarget(e)) { |
||
| 637 | daniel-mar | 10748 | mouseHandlers.mousedown(fromRawEvent(e)); |
| 597 | daniel-mar | 10749 | } |
| 10750 | }; |
||
| 10751 | var mouseOver = function (e) { |
||
| 10752 | if (isLeftButtonPressed(e) && hasInternalTarget(e)) { |
||
| 637 | daniel-mar | 10753 | mouseHandlers.mouseover(fromRawEvent(e)); |
| 597 | daniel-mar | 10754 | } |
| 10755 | }; |
||
| 10756 | var mouseUp = function (e) { |
||
| 10757 | if (isLeftMouse(e) && hasInternalTarget(e)) { |
||
| 637 | daniel-mar | 10758 | mouseHandlers.mouseup(fromRawEvent(e)); |
| 597 | daniel-mar | 10759 | } |
| 10760 | }; |
||
| 10761 | var getDoubleTap = function () { |
||
| 10762 | var lastTarget = Cell(SugarElement.fromDom(body)); |
||
| 10763 | var lastTimeStamp = Cell(0); |
||
| 10764 | var touchEnd = function (t) { |
||
| 10765 | var target = SugarElement.fromDom(t.target); |
||
| 10766 | if (name(target) === 'td' || name(target) === 'th') { |
||
| 10767 | var lT = lastTarget.get(); |
||
| 10768 | var lTS = lastTimeStamp.get(); |
||
| 10769 | if (eq$1(lT, target) && t.timeStamp - lTS < 300) { |
||
| 10770 | t.preventDefault(); |
||
| 10771 | external$1(target, target); |
||
| 10772 | } |
||
| 10773 | } |
||
| 10774 | lastTarget.set(target); |
||
| 10775 | lastTimeStamp.set(t.timeStamp); |
||
| 10776 | }; |
||
| 10777 | return { touchEnd: touchEnd }; |
||
| 10778 | }; |
||
| 10779 | var doubleTap = getDoubleTap(); |
||
| 10780 | editor.on('dragstart', dragStart); |
||
| 10781 | editor.on('mousedown', mouseDown); |
||
| 10782 | editor.on('mouseover', mouseOver); |
||
| 10783 | editor.on('mouseup', mouseUp); |
||
| 10784 | editor.on('touchend', doubleTap.touchEnd); |
||
| 10785 | editor.on('keyup', keyup); |
||
| 10786 | editor.on('keydown', keydown); |
||
| 10787 | editor.on('NodeChange', syncSelection); |
||
| 10788 | }); |
||
| 10789 | return { clear: annotations.clear }; |
||
| 10790 | } |
||
| 10791 | |||
| 637 | daniel-mar | 10792 | var child = function (scope, selector) { |
| 10793 | return child$1(scope, selector).isSome(); |
||
| 10794 | }; |
||
| 10795 | |||
| 597 | daniel-mar | 10796 | var getSelectionTargets = function (editor, selections) { |
| 10797 | var targets = Cell(Optional.none()); |
||
| 10798 | var changeHandlers = Cell([]); |
||
| 10799 | var selectionDetails = Optional.none(); |
||
| 10800 | var isCaption = isTag('caption'); |
||
| 10801 | var isDisabledForSelection = function (key) { |
||
| 10802 | return selectionDetails.forall(function (details) { |
||
| 10803 | return !details[key]; |
||
| 10804 | }); |
||
| 10805 | }; |
||
| 637 | daniel-mar | 10806 | var getStart = function () { |
| 10807 | return getSelectionCellOrCaption(getSelectionStart(editor), getIsRoot(editor)); |
||
| 10808 | }; |
||
| 10809 | var getEnd = function () { |
||
| 10810 | return getSelectionCellOrCaption(getSelectionEnd(editor), getIsRoot(editor)); |
||
| 10811 | }; |
||
| 597 | daniel-mar | 10812 | var findTargets = function () { |
| 637 | daniel-mar | 10813 | return getStart().bind(function (startCellOrCaption) { |
| 10814 | return flatten(lift2(table(startCellOrCaption), getEnd().bind(table), function (startTable, endTable) { |
||
| 10815 | if (eq$1(startTable, endTable)) { |
||
| 10816 | if (isCaption(startCellOrCaption)) { |
||
| 10817 | return Optional.some(noMenu(startCellOrCaption)); |
||
| 10818 | } else { |
||
| 10819 | return Optional.some(forMenu(selections, startTable, startCellOrCaption)); |
||
| 10820 | } |
||
| 597 | daniel-mar | 10821 | } |
| 637 | daniel-mar | 10822 | return Optional.none(); |
| 10823 | })); |
||
| 597 | daniel-mar | 10824 | }); |
| 10825 | }; |
||
| 10826 | var getExtractedDetails = function (targets) { |
||
| 10827 | var tableOpt = table(targets.element); |
||
| 10828 | return tableOpt.map(function (table) { |
||
| 10829 | var warehouse = Warehouse.fromTable(table); |
||
| 10830 | var selectedCells = onCells(warehouse, targets).getOr([]); |
||
| 10831 | var locked = foldl(selectedCells, function (acc, cell) { |
||
| 10832 | if (cell.isLocked) { |
||
| 10833 | acc.onAny = true; |
||
| 10834 | if (cell.column === 0) { |
||
| 10835 | acc.onFirst = true; |
||
| 10836 | } else if (cell.column + cell.colspan >= warehouse.grid.columns) { |
||
| 10837 | acc.onLast = true; |
||
| 10838 | } |
||
| 10839 | } |
||
| 10840 | return acc; |
||
| 10841 | }, { |
||
| 10842 | onAny: false, |
||
| 10843 | onFirst: false, |
||
| 10844 | onLast: false |
||
| 10845 | }); |
||
| 10846 | return { |
||
| 10847 | mergeable: onUnlockedMergable(warehouse, targets).isSome(), |
||
| 10848 | unmergeable: onUnlockedUnmergable(warehouse, targets).isSome(), |
||
| 10849 | locked: locked |
||
| 10850 | }; |
||
| 10851 | }); |
||
| 10852 | }; |
||
| 10853 | var resetTargets = function () { |
||
| 10854 | targets.set(cached(findTargets)()); |
||
| 10855 | selectionDetails = targets.get().bind(getExtractedDetails); |
||
| 637 | daniel-mar | 10856 | each$2(changeHandlers.get(), function (handler) { |
| 597 | daniel-mar | 10857 | return handler(); |
| 10858 | }); |
||
| 10859 | }; |
||
| 637 | daniel-mar | 10860 | var setupHandler = function (handler) { |
| 597 | daniel-mar | 10861 | handler(); |
| 10862 | changeHandlers.set(changeHandlers.get().concat([handler])); |
||
| 10863 | return function () { |
||
| 637 | daniel-mar | 10864 | changeHandlers.set(filter$2(changeHandlers.get(), function (h) { |
| 597 | daniel-mar | 10865 | return h !== handler; |
| 10866 | })); |
||
| 10867 | }; |
||
| 10868 | }; |
||
| 637 | daniel-mar | 10869 | var onSetup = function (api, isDisabled) { |
| 10870 | return setupHandler(function () { |
||
| 10871 | return targets.get().fold(function () { |
||
| 10872 | api.setDisabled(true); |
||
| 10873 | }, function (targets) { |
||
| 10874 | api.setDisabled(isDisabled(targets)); |
||
| 10875 | }); |
||
| 10876 | }); |
||
| 10877 | }; |
||
| 10878 | var onSetupWithToggle = function (api, isDisabled, isActive) { |
||
| 10879 | return setupHandler(function () { |
||
| 10880 | return targets.get().fold(function () { |
||
| 10881 | api.setDisabled(true); |
||
| 10882 | api.setActive(false); |
||
| 10883 | }, function (targets) { |
||
| 10884 | api.setDisabled(isDisabled(targets)); |
||
| 10885 | api.setActive(isActive(targets)); |
||
| 10886 | }); |
||
| 10887 | }); |
||
| 10888 | }; |
||
| 597 | daniel-mar | 10889 | var isDisabledFromLocked = function (lockedDisable) { |
| 10890 | return selectionDetails.exists(function (details) { |
||
| 10891 | return details.locked[lockedDisable]; |
||
| 10892 | }); |
||
| 10893 | }; |
||
| 10894 | var onSetupTable = function (api) { |
||
| 10895 | return onSetup(api, function (_) { |
||
| 10896 | return false; |
||
| 10897 | }); |
||
| 10898 | }; |
||
| 10899 | var onSetupCellOrRow = function (api) { |
||
| 10900 | return onSetup(api, function (targets) { |
||
| 10901 | return isCaption(targets.element); |
||
| 10902 | }); |
||
| 10903 | }; |
||
| 10904 | var onSetupColumn = function (lockedDisable) { |
||
| 10905 | return function (api) { |
||
| 10906 | return onSetup(api, function (targets) { |
||
| 10907 | return isCaption(targets.element) || isDisabledFromLocked(lockedDisable); |
||
| 10908 | }); |
||
| 10909 | }; |
||
| 10910 | }; |
||
| 10911 | var onSetupPasteable = function (getClipboardData) { |
||
| 10912 | return function (api) { |
||
| 10913 | return onSetup(api, function (targets) { |
||
| 10914 | return isCaption(targets.element) || getClipboardData().isNone(); |
||
| 10915 | }); |
||
| 10916 | }; |
||
| 10917 | }; |
||
| 10918 | var onSetupPasteableColumn = function (getClipboardData, lockedDisable) { |
||
| 10919 | return function (api) { |
||
| 10920 | return onSetup(api, function (targets) { |
||
| 10921 | return isCaption(targets.element) || getClipboardData().isNone() || isDisabledFromLocked(lockedDisable); |
||
| 10922 | }); |
||
| 10923 | }; |
||
| 10924 | }; |
||
| 10925 | var onSetupMergeable = function (api) { |
||
| 10926 | return onSetup(api, function (_targets) { |
||
| 10927 | return isDisabledForSelection('mergeable'); |
||
| 10928 | }); |
||
| 10929 | }; |
||
| 10930 | var onSetupUnmergeable = function (api) { |
||
| 10931 | return onSetup(api, function (_targets) { |
||
| 10932 | return isDisabledForSelection('unmergeable'); |
||
| 10933 | }); |
||
| 10934 | }; |
||
| 637 | daniel-mar | 10935 | var onSetupTableWithCaption = function (api) { |
| 10936 | return onSetupWithToggle(api, never, function (targets) { |
||
| 10937 | var tableOpt = table(targets.element, getIsRoot(editor)); |
||
| 10938 | return tableOpt.exists(function (table) { |
||
| 10939 | return child(table, 'caption'); |
||
| 10940 | }); |
||
| 10941 | }); |
||
| 10942 | }; |
||
| 10943 | var onSetupTableHeaders = function (command, headerType) { |
||
| 10944 | return function (api) { |
||
| 10945 | return onSetupWithToggle(api, function (targets) { |
||
| 10946 | return isCaption(targets.element); |
||
| 10947 | }, function () { |
||
| 10948 | return editor.queryCommandValue(command) === headerType; |
||
| 10949 | }); |
||
| 10950 | }; |
||
| 10951 | }; |
||
| 10952 | var onSetupTableRowHeaders = onSetupTableHeaders('mceTableRowType', 'header'); |
||
| 10953 | var onSetupTableColumnHeaders = onSetupTableHeaders('mceTableColType', 'th'); |
||
| 597 | daniel-mar | 10954 | editor.on('NodeChange ExecCommand TableSelectorChange', resetTargets); |
| 10955 | return { |
||
| 10956 | onSetupTable: onSetupTable, |
||
| 10957 | onSetupCellOrRow: onSetupCellOrRow, |
||
| 10958 | onSetupColumn: onSetupColumn, |
||
| 10959 | onSetupPasteable: onSetupPasteable, |
||
| 10960 | onSetupPasteableColumn: onSetupPasteableColumn, |
||
| 10961 | onSetupMergeable: onSetupMergeable, |
||
| 10962 | onSetupUnmergeable: onSetupUnmergeable, |
||
| 10963 | resetTargets: resetTargets, |
||
| 637 | daniel-mar | 10964 | onSetupTableWithCaption: onSetupTableWithCaption, |
| 10965 | onSetupTableRowHeaders: onSetupTableRowHeaders, |
||
| 10966 | onSetupTableColumnHeaders: onSetupTableColumnHeaders, |
||
| 10967 | targets: targets.get |
||
| 597 | daniel-mar | 10968 | }; |
| 10969 | }; |
||
| 10970 | |||
| 637 | daniel-mar | 10971 | var addButtons = function (editor, selections, selectionTargets, clipboard) { |
| 597 | daniel-mar | 10972 | editor.ui.registry.addMenuButton('table', { |
| 10973 | tooltip: 'Table', |
||
| 10974 | icon: 'table', |
||
| 10975 | fetch: function (callback) { |
||
| 10976 | return callback('inserttable | cell row column | advtablesort | tableprops deletetable'); |
||
| 10977 | } |
||
| 10978 | }); |
||
| 10979 | var cmd = function (command) { |
||
| 10980 | return function () { |
||
| 10981 | return editor.execCommand(command); |
||
| 10982 | }; |
||
| 10983 | }; |
||
| 10984 | editor.ui.registry.addButton('tableprops', { |
||
| 10985 | tooltip: 'Table properties', |
||
| 10986 | onAction: cmd('mceTableProps'), |
||
| 10987 | icon: 'table', |
||
| 10988 | onSetup: selectionTargets.onSetupTable |
||
| 10989 | }); |
||
| 10990 | editor.ui.registry.addButton('tabledelete', { |
||
| 10991 | tooltip: 'Delete table', |
||
| 10992 | onAction: cmd('mceTableDelete'), |
||
| 10993 | icon: 'table-delete-table', |
||
| 10994 | onSetup: selectionTargets.onSetupTable |
||
| 10995 | }); |
||
| 10996 | editor.ui.registry.addButton('tablecellprops', { |
||
| 10997 | tooltip: 'Cell properties', |
||
| 10998 | onAction: cmd('mceTableCellProps'), |
||
| 10999 | icon: 'table-cell-properties', |
||
| 11000 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11001 | }); |
||
| 11002 | editor.ui.registry.addButton('tablemergecells', { |
||
| 11003 | tooltip: 'Merge cells', |
||
| 11004 | onAction: cmd('mceTableMergeCells'), |
||
| 11005 | icon: 'table-merge-cells', |
||
| 11006 | onSetup: selectionTargets.onSetupMergeable |
||
| 11007 | }); |
||
| 11008 | editor.ui.registry.addButton('tablesplitcells', { |
||
| 11009 | tooltip: 'Split cell', |
||
| 11010 | onAction: cmd('mceTableSplitCells'), |
||
| 11011 | icon: 'table-split-cells', |
||
| 11012 | onSetup: selectionTargets.onSetupUnmergeable |
||
| 11013 | }); |
||
| 11014 | editor.ui.registry.addButton('tableinsertrowbefore', { |
||
| 11015 | tooltip: 'Insert row before', |
||
| 11016 | onAction: cmd('mceTableInsertRowBefore'), |
||
| 11017 | icon: 'table-insert-row-above', |
||
| 11018 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11019 | }); |
||
| 11020 | editor.ui.registry.addButton('tableinsertrowafter', { |
||
| 11021 | tooltip: 'Insert row after', |
||
| 11022 | onAction: cmd('mceTableInsertRowAfter'), |
||
| 11023 | icon: 'table-insert-row-after', |
||
| 11024 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11025 | }); |
||
| 11026 | editor.ui.registry.addButton('tabledeleterow', { |
||
| 11027 | tooltip: 'Delete row', |
||
| 11028 | onAction: cmd('mceTableDeleteRow'), |
||
| 11029 | icon: 'table-delete-row', |
||
| 11030 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11031 | }); |
||
| 11032 | editor.ui.registry.addButton('tablerowprops', { |
||
| 11033 | tooltip: 'Row properties', |
||
| 11034 | onAction: cmd('mceTableRowProps'), |
||
| 11035 | icon: 'table-row-properties', |
||
| 11036 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11037 | }); |
||
| 11038 | editor.ui.registry.addButton('tableinsertcolbefore', { |
||
| 11039 | tooltip: 'Insert column before', |
||
| 11040 | onAction: cmd('mceTableInsertColBefore'), |
||
| 11041 | icon: 'table-insert-column-before', |
||
| 11042 | onSetup: selectionTargets.onSetupColumn('onFirst') |
||
| 11043 | }); |
||
| 11044 | editor.ui.registry.addButton('tableinsertcolafter', { |
||
| 11045 | tooltip: 'Insert column after', |
||
| 11046 | onAction: cmd('mceTableInsertColAfter'), |
||
| 11047 | icon: 'table-insert-column-after', |
||
| 11048 | onSetup: selectionTargets.onSetupColumn('onLast') |
||
| 11049 | }); |
||
| 11050 | editor.ui.registry.addButton('tabledeletecol', { |
||
| 11051 | tooltip: 'Delete column', |
||
| 11052 | onAction: cmd('mceTableDeleteCol'), |
||
| 11053 | icon: 'table-delete-column', |
||
| 11054 | onSetup: selectionTargets.onSetupColumn('onAny') |
||
| 11055 | }); |
||
| 11056 | editor.ui.registry.addButton('tablecutrow', { |
||
| 11057 | tooltip: 'Cut row', |
||
| 11058 | icon: 'cut-row', |
||
| 11059 | onAction: cmd('mceTableCutRow'), |
||
| 11060 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11061 | }); |
||
| 11062 | editor.ui.registry.addButton('tablecopyrow', { |
||
| 11063 | tooltip: 'Copy row', |
||
| 11064 | icon: 'duplicate-row', |
||
| 11065 | onAction: cmd('mceTableCopyRow'), |
||
| 11066 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11067 | }); |
||
| 11068 | editor.ui.registry.addButton('tablepasterowbefore', { |
||
| 11069 | tooltip: 'Paste row before', |
||
| 11070 | icon: 'paste-row-before', |
||
| 11071 | onAction: cmd('mceTablePasteRowBefore'), |
||
| 11072 | onSetup: selectionTargets.onSetupPasteable(clipboard.getRows) |
||
| 11073 | }); |
||
| 11074 | editor.ui.registry.addButton('tablepasterowafter', { |
||
| 11075 | tooltip: 'Paste row after', |
||
| 11076 | icon: 'paste-row-after', |
||
| 11077 | onAction: cmd('mceTablePasteRowAfter'), |
||
| 11078 | onSetup: selectionTargets.onSetupPasteable(clipboard.getRows) |
||
| 11079 | }); |
||
| 11080 | editor.ui.registry.addButton('tablecutcol', { |
||
| 11081 | tooltip: 'Cut column', |
||
| 11082 | icon: 'cut-column', |
||
| 11083 | onAction: cmd('mceTableCutCol'), |
||
| 11084 | onSetup: selectionTargets.onSetupColumn('onAny') |
||
| 11085 | }); |
||
| 11086 | editor.ui.registry.addButton('tablecopycol', { |
||
| 11087 | tooltip: 'Copy column', |
||
| 11088 | icon: 'duplicate-column', |
||
| 11089 | onAction: cmd('mceTableCopyCol'), |
||
| 11090 | onSetup: selectionTargets.onSetupColumn('onAny') |
||
| 11091 | }); |
||
| 11092 | editor.ui.registry.addButton('tablepastecolbefore', { |
||
| 11093 | tooltip: 'Paste column before', |
||
| 11094 | icon: 'paste-column-before', |
||
| 11095 | onAction: cmd('mceTablePasteColBefore'), |
||
| 11096 | onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onFirst') |
||
| 11097 | }); |
||
| 11098 | editor.ui.registry.addButton('tablepastecolafter', { |
||
| 11099 | tooltip: 'Paste column after', |
||
| 11100 | icon: 'paste-column-after', |
||
| 11101 | onAction: cmd('mceTablePasteColAfter'), |
||
| 11102 | onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onLast') |
||
| 11103 | }); |
||
| 11104 | editor.ui.registry.addButton('tableinsertdialog', { |
||
| 11105 | tooltip: 'Insert table', |
||
| 11106 | onAction: cmd('mceInsertTable'), |
||
| 11107 | icon: 'table' |
||
| 11108 | }); |
||
| 637 | daniel-mar | 11109 | var tableClassList = filterNoneItem(getTableClassList(editor)); |
| 11110 | if (tableClassList.length !== 0) { |
||
| 11111 | editor.ui.registry.addMenuButton('tableclass', { |
||
| 11112 | icon: 'table-classes', |
||
| 11113 | tooltip: 'Table styles', |
||
| 11114 | fetch: generateMenuItemsCallback(editor, selections, tableClassList, 'tableclass', function (value) { |
||
| 11115 | return editor.execCommand('mceTableToggleClass', false, value); |
||
| 11116 | }), |
||
| 11117 | onSetup: selectionTargets.onSetupTable |
||
| 11118 | }); |
||
| 11119 | } |
||
| 11120 | var tableCellClassList = filterNoneItem(getCellClassList(editor)); |
||
| 11121 | if (tableCellClassList.length !== 0) { |
||
| 11122 | editor.ui.registry.addMenuButton('tablecellclass', { |
||
| 11123 | icon: 'table-cell-classes', |
||
| 11124 | tooltip: 'Cell styles', |
||
| 11125 | fetch: generateMenuItemsCallback(editor, selections, tableCellClassList, 'tablecellclass', function (value) { |
||
| 11126 | return editor.execCommand('mceTableCellToggleClass', false, value); |
||
| 11127 | }), |
||
| 11128 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11129 | }); |
||
| 11130 | } |
||
| 11131 | editor.ui.registry.addMenuButton('tablecellvalign', { |
||
| 11132 | icon: 'vertical-align', |
||
| 11133 | tooltip: 'Vertical align', |
||
| 11134 | fetch: generateMenuItemsCallback(editor, selections, verticalAlignValues, 'tablecellverticalalign', applyTableCellStyle(editor, 'vertical-align')), |
||
| 11135 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11136 | }); |
||
| 11137 | editor.ui.registry.addMenuButton('tablecellborderwidth', { |
||
| 11138 | icon: 'border-width', |
||
| 11139 | tooltip: 'Border width', |
||
| 11140 | fetch: generateMenuItemsCallback(editor, selections, getTableBorderWidths(editor), 'tablecellborderwidth', applyTableCellStyle(editor, 'border-width')), |
||
| 11141 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11142 | }); |
||
| 11143 | editor.ui.registry.addMenuButton('tablecellborderstyle', { |
||
| 11144 | icon: 'border-style', |
||
| 11145 | tooltip: 'Border style', |
||
| 11146 | fetch: generateMenuItemsCallback(editor, selections, getTableBorderStyles(editor), 'tablecellborderstyle', applyTableCellStyle(editor, 'border-style')), |
||
| 11147 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11148 | }); |
||
| 11149 | editor.ui.registry.addToggleButton('tablecaption', { |
||
| 11150 | tooltip: 'Table caption', |
||
| 11151 | onAction: cmd('mceTableToggleCaption'), |
||
| 11152 | icon: 'table-caption', |
||
| 11153 | onSetup: selectionTargets.onSetupTableWithCaption |
||
| 11154 | }); |
||
| 11155 | editor.ui.registry.addMenuButton('tablecellbackgroundcolor', { |
||
| 11156 | icon: 'cell-background-color', |
||
| 11157 | tooltip: 'Background color', |
||
| 11158 | fetch: function (callback) { |
||
| 11159 | return callback(buildColorMenu(editor, getTableBackgroundColorMap(editor), 'background-color')); |
||
| 11160 | }, |
||
| 11161 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11162 | }); |
||
| 11163 | editor.ui.registry.addMenuButton('tablecellbordercolor', { |
||
| 11164 | icon: 'cell-border-color', |
||
| 11165 | tooltip: 'Border color', |
||
| 11166 | fetch: function (callback) { |
||
| 11167 | return callback(buildColorMenu(editor, getTableBorderColorMap(editor), 'border-color')); |
||
| 11168 | }, |
||
| 11169 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11170 | }); |
||
| 11171 | editor.ui.registry.addToggleButton('tablerowheader', { |
||
| 11172 | tooltip: 'Row header', |
||
| 11173 | icon: 'table-top-header', |
||
| 11174 | onAction: changeRowHeader(editor), |
||
| 11175 | onSetup: selectionTargets.onSetupTableRowHeaders |
||
| 11176 | }); |
||
| 11177 | editor.ui.registry.addToggleButton('tablecolheader', { |
||
| 11178 | tooltip: 'Column header', |
||
| 11179 | icon: 'table-left-header', |
||
| 11180 | onAction: changeColumnHeader(editor), |
||
| 11181 | onSetup: selectionTargets.onSetupTableColumnHeaders |
||
| 11182 | }); |
||
| 597 | daniel-mar | 11183 | }; |
| 11184 | var addToolbars = function (editor) { |
||
| 11185 | var isTable = function (table) { |
||
| 11186 | return editor.dom.is(table, 'table') && editor.getBody().contains(table); |
||
| 11187 | }; |
||
| 11188 | var toolbar = getToolbar(editor); |
||
| 11189 | if (toolbar.length > 0) { |
||
| 11190 | editor.ui.registry.addContextToolbar('table', { |
||
| 11191 | predicate: isTable, |
||
| 11192 | items: toolbar, |
||
| 11193 | scope: 'node', |
||
| 11194 | position: 'node' |
||
| 11195 | }); |
||
| 11196 | } |
||
| 11197 | }; |
||
| 11198 | |||
| 637 | daniel-mar | 11199 | var addMenuItems = function (editor, selections, selectionTargets, clipboard) { |
| 597 | daniel-mar | 11200 | var cmd = function (command) { |
| 11201 | return function () { |
||
| 11202 | return editor.execCommand(command); |
||
| 11203 | }; |
||
| 11204 | }; |
||
| 11205 | var insertTableAction = function (data) { |
||
| 11206 | editor.execCommand('mceInsertTable', false, { |
||
| 11207 | rows: data.numRows, |
||
| 11208 | columns: data.numColumns |
||
| 11209 | }); |
||
| 11210 | }; |
||
| 11211 | var tableProperties = { |
||
| 11212 | text: 'Table properties', |
||
| 11213 | onSetup: selectionTargets.onSetupTable, |
||
| 11214 | onAction: cmd('mceTableProps') |
||
| 11215 | }; |
||
| 11216 | var deleteTable = { |
||
| 11217 | text: 'Delete table', |
||
| 11218 | icon: 'table-delete-table', |
||
| 11219 | onSetup: selectionTargets.onSetupTable, |
||
| 11220 | onAction: cmd('mceTableDelete') |
||
| 11221 | }; |
||
| 11222 | editor.ui.registry.addMenuItem('tableinsertrowbefore', { |
||
| 11223 | text: 'Insert row before', |
||
| 11224 | icon: 'table-insert-row-above', |
||
| 11225 | onAction: cmd('mceTableInsertRowBefore'), |
||
| 11226 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11227 | }); |
||
| 11228 | editor.ui.registry.addMenuItem('tableinsertrowafter', { |
||
| 11229 | text: 'Insert row after', |
||
| 11230 | icon: 'table-insert-row-after', |
||
| 11231 | onAction: cmd('mceTableInsertRowAfter'), |
||
| 11232 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11233 | }); |
||
| 11234 | editor.ui.registry.addMenuItem('tabledeleterow', { |
||
| 11235 | text: 'Delete row', |
||
| 11236 | icon: 'table-delete-row', |
||
| 11237 | onAction: cmd('mceTableDeleteRow'), |
||
| 11238 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11239 | }); |
||
| 11240 | editor.ui.registry.addMenuItem('tablerowprops', { |
||
| 11241 | text: 'Row properties', |
||
| 11242 | icon: 'table-row-properties', |
||
| 11243 | onAction: cmd('mceTableRowProps'), |
||
| 11244 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11245 | }); |
||
| 11246 | editor.ui.registry.addMenuItem('tablecutrow', { |
||
| 11247 | text: 'Cut row', |
||
| 11248 | icon: 'cut-row', |
||
| 11249 | onAction: cmd('mceTableCutRow'), |
||
| 11250 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11251 | }); |
||
| 11252 | editor.ui.registry.addMenuItem('tablecopyrow', { |
||
| 11253 | text: 'Copy row', |
||
| 11254 | icon: 'duplicate-row', |
||
| 11255 | onAction: cmd('mceTableCopyRow'), |
||
| 11256 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11257 | }); |
||
| 11258 | editor.ui.registry.addMenuItem('tablepasterowbefore', { |
||
| 11259 | text: 'Paste row before', |
||
| 11260 | icon: 'paste-row-before', |
||
| 11261 | onAction: cmd('mceTablePasteRowBefore'), |
||
| 11262 | onSetup: selectionTargets.onSetupPasteable(clipboard.getRows) |
||
| 11263 | }); |
||
| 11264 | editor.ui.registry.addMenuItem('tablepasterowafter', { |
||
| 11265 | text: 'Paste row after', |
||
| 11266 | icon: 'paste-row-after', |
||
| 11267 | onAction: cmd('mceTablePasteRowAfter'), |
||
| 11268 | onSetup: selectionTargets.onSetupPasteable(clipboard.getRows) |
||
| 11269 | }); |
||
| 11270 | var row = { |
||
| 11271 | type: 'nestedmenuitem', |
||
| 11272 | text: 'Row', |
||
| 637 | daniel-mar | 11273 | getSubmenuItems: constant('tableinsertrowbefore tableinsertrowafter tabledeleterow tablerowprops | tablecutrow tablecopyrow tablepasterowbefore tablepasterowafter') |
| 597 | daniel-mar | 11274 | }; |
| 11275 | editor.ui.registry.addMenuItem('tableinsertcolumnbefore', { |
||
| 11276 | text: 'Insert column before', |
||
| 11277 | icon: 'table-insert-column-before', |
||
| 11278 | onAction: cmd('mceTableInsertColBefore'), |
||
| 11279 | onSetup: selectionTargets.onSetupColumn('onFirst') |
||
| 11280 | }); |
||
| 11281 | editor.ui.registry.addMenuItem('tableinsertcolumnafter', { |
||
| 11282 | text: 'Insert column after', |
||
| 11283 | icon: 'table-insert-column-after', |
||
| 11284 | onAction: cmd('mceTableInsertColAfter'), |
||
| 11285 | onSetup: selectionTargets.onSetupColumn('onLast') |
||
| 11286 | }); |
||
| 11287 | editor.ui.registry.addMenuItem('tabledeletecolumn', { |
||
| 11288 | text: 'Delete column', |
||
| 11289 | icon: 'table-delete-column', |
||
| 11290 | onAction: cmd('mceTableDeleteCol'), |
||
| 11291 | onSetup: selectionTargets.onSetupColumn('onAny') |
||
| 11292 | }); |
||
| 11293 | editor.ui.registry.addMenuItem('tablecutcolumn', { |
||
| 11294 | text: 'Cut column', |
||
| 11295 | icon: 'cut-column', |
||
| 11296 | onAction: cmd('mceTableCutCol'), |
||
| 11297 | onSetup: selectionTargets.onSetupColumn('onAny') |
||
| 11298 | }); |
||
| 11299 | editor.ui.registry.addMenuItem('tablecopycolumn', { |
||
| 11300 | text: 'Copy column', |
||
| 11301 | icon: 'duplicate-column', |
||
| 11302 | onAction: cmd('mceTableCopyCol'), |
||
| 11303 | onSetup: selectionTargets.onSetupColumn('onAny') |
||
| 11304 | }); |
||
| 11305 | editor.ui.registry.addMenuItem('tablepastecolumnbefore', { |
||
| 11306 | text: 'Paste column before', |
||
| 11307 | icon: 'paste-column-before', |
||
| 11308 | onAction: cmd('mceTablePasteColBefore'), |
||
| 11309 | onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onFirst') |
||
| 11310 | }); |
||
| 11311 | editor.ui.registry.addMenuItem('tablepastecolumnafter', { |
||
| 11312 | text: 'Paste column after', |
||
| 11313 | icon: 'paste-column-after', |
||
| 11314 | onAction: cmd('mceTablePasteColAfter'), |
||
| 11315 | onSetup: selectionTargets.onSetupPasteableColumn(clipboard.getColumns, 'onLast') |
||
| 11316 | }); |
||
| 11317 | var column = { |
||
| 11318 | type: 'nestedmenuitem', |
||
| 11319 | text: 'Column', |
||
| 637 | daniel-mar | 11320 | getSubmenuItems: constant('tableinsertcolumnbefore tableinsertcolumnafter tabledeletecolumn | tablecutcolumn tablecopycolumn tablepastecolumnbefore tablepastecolumnafter') |
| 597 | daniel-mar | 11321 | }; |
| 11322 | editor.ui.registry.addMenuItem('tablecellprops', { |
||
| 11323 | text: 'Cell properties', |
||
| 11324 | icon: 'table-cell-properties', |
||
| 11325 | onAction: cmd('mceTableCellProps'), |
||
| 11326 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11327 | }); |
||
| 11328 | editor.ui.registry.addMenuItem('tablemergecells', { |
||
| 11329 | text: 'Merge cells', |
||
| 11330 | icon: 'table-merge-cells', |
||
| 11331 | onAction: cmd('mceTableMergeCells'), |
||
| 11332 | onSetup: selectionTargets.onSetupMergeable |
||
| 11333 | }); |
||
| 11334 | editor.ui.registry.addMenuItem('tablesplitcells', { |
||
| 11335 | text: 'Split cell', |
||
| 11336 | icon: 'table-split-cells', |
||
| 11337 | onAction: cmd('mceTableSplitCells'), |
||
| 11338 | onSetup: selectionTargets.onSetupUnmergeable |
||
| 11339 | }); |
||
| 11340 | var cell = { |
||
| 11341 | type: 'nestedmenuitem', |
||
| 11342 | text: 'Cell', |
||
| 637 | daniel-mar | 11343 | getSubmenuItems: constant('tablecellprops tablemergecells tablesplitcells') |
| 597 | daniel-mar | 11344 | }; |
| 11345 | if (hasTableGrid(editor) === false) { |
||
| 11346 | editor.ui.registry.addMenuItem('inserttable', { |
||
| 11347 | text: 'Table', |
||
| 11348 | icon: 'table', |
||
| 11349 | onAction: cmd('mceInsertTable') |
||
| 11350 | }); |
||
| 11351 | } else { |
||
| 11352 | editor.ui.registry.addNestedMenuItem('inserttable', { |
||
| 11353 | text: 'Table', |
||
| 11354 | icon: 'table', |
||
| 11355 | getSubmenuItems: function () { |
||
| 11356 | return [{ |
||
| 11357 | type: 'fancymenuitem', |
||
| 11358 | fancytype: 'inserttable', |
||
| 11359 | onAction: insertTableAction |
||
| 11360 | }]; |
||
| 11361 | } |
||
| 11362 | }); |
||
| 11363 | } |
||
| 11364 | editor.ui.registry.addMenuItem('inserttabledialog', { |
||
| 11365 | text: 'Insert table', |
||
| 11366 | icon: 'table', |
||
| 11367 | onAction: cmd('mceInsertTable') |
||
| 11368 | }); |
||
| 11369 | editor.ui.registry.addMenuItem('tableprops', tableProperties); |
||
| 11370 | editor.ui.registry.addMenuItem('deletetable', deleteTable); |
||
| 11371 | editor.ui.registry.addNestedMenuItem('row', row); |
||
| 11372 | editor.ui.registry.addNestedMenuItem('column', column); |
||
| 11373 | editor.ui.registry.addNestedMenuItem('cell', cell); |
||
| 11374 | editor.ui.registry.addContextMenu('table', { |
||
| 11375 | update: function () { |
||
| 11376 | selectionTargets.resetTargets(); |
||
| 637 | daniel-mar | 11377 | return selectionTargets.targets().fold(constant(''), function (targets) { |
| 597 | daniel-mar | 11378 | if (name(targets.element) === 'caption') { |
| 11379 | return 'tableprops deletetable'; |
||
| 11380 | } else { |
||
| 11381 | return 'cell row column | advtablesort | tableprops deletetable'; |
||
| 11382 | } |
||
| 11383 | }); |
||
| 11384 | } |
||
| 11385 | }); |
||
| 637 | daniel-mar | 11386 | var tableClassList = filterNoneItem(getTableClassList(editor)); |
| 11387 | if (tableClassList.length !== 0) { |
||
| 11388 | editor.ui.registry.addNestedMenuItem('tableclass', { |
||
| 11389 | icon: 'table-classes', |
||
| 11390 | text: 'Table styles', |
||
| 11391 | getSubmenuItems: function () { |
||
| 11392 | return buildMenuItems(editor, selections, tableClassList, 'tableclass', function (value) { |
||
| 11393 | return editor.execCommand('mceTableToggleClass', false, value); |
||
| 11394 | }); |
||
| 11395 | }, |
||
| 11396 | onSetup: selectionTargets.onSetupTable |
||
| 11397 | }); |
||
| 11398 | } |
||
| 11399 | var tableCellClassList = filterNoneItem(getCellClassList(editor)); |
||
| 11400 | if (tableCellClassList.length !== 0) { |
||
| 11401 | editor.ui.registry.addNestedMenuItem('tablecellclass', { |
||
| 11402 | icon: 'table-cell-classes', |
||
| 11403 | text: 'Cell styles', |
||
| 11404 | getSubmenuItems: function () { |
||
| 11405 | return buildMenuItems(editor, selections, tableCellClassList, 'tablecellclass', function (value) { |
||
| 11406 | return editor.execCommand('mceTableCellToggleClass', false, value); |
||
| 11407 | }); |
||
| 11408 | }, |
||
| 11409 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11410 | }); |
||
| 11411 | } |
||
| 11412 | editor.ui.registry.addNestedMenuItem('tablecellvalign', { |
||
| 11413 | icon: 'vertical-align', |
||
| 11414 | text: 'Vertical align', |
||
| 11415 | getSubmenuItems: function () { |
||
| 11416 | return buildMenuItems(editor, selections, verticalAlignValues, 'tablecellverticalalign', applyTableCellStyle(editor, 'vertical-align')); |
||
| 11417 | }, |
||
| 11418 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11419 | }); |
||
| 11420 | editor.ui.registry.addNestedMenuItem('tablecellborderwidth', { |
||
| 11421 | icon: 'border-width', |
||
| 11422 | text: 'Border width', |
||
| 11423 | getSubmenuItems: function () { |
||
| 11424 | return buildMenuItems(editor, selections, getTableBorderWidths(editor), 'tablecellborderwidth', applyTableCellStyle(editor, 'border-width')); |
||
| 11425 | }, |
||
| 11426 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11427 | }); |
||
| 11428 | editor.ui.registry.addNestedMenuItem('tablecellborderstyle', { |
||
| 11429 | icon: 'border-style', |
||
| 11430 | text: 'Border style', |
||
| 11431 | getSubmenuItems: function () { |
||
| 11432 | return buildMenuItems(editor, selections, getTableBorderStyles(editor), 'tablecellborderstyle', applyTableCellStyle(editor, 'border-style')); |
||
| 11433 | }, |
||
| 11434 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11435 | }); |
||
| 11436 | editor.ui.registry.addToggleMenuItem('tablecaption', { |
||
| 11437 | icon: 'table-caption', |
||
| 11438 | text: 'Table caption', |
||
| 11439 | onAction: cmd('mceTableToggleCaption'), |
||
| 11440 | onSetup: selectionTargets.onSetupTableWithCaption |
||
| 11441 | }); |
||
| 11442 | editor.ui.registry.addNestedMenuItem('tablecellbackgroundcolor', { |
||
| 11443 | icon: 'cell-background-color', |
||
| 11444 | text: 'Background color', |
||
| 11445 | getSubmenuItems: function () { |
||
| 11446 | return buildColorMenu(editor, getTableBackgroundColorMap(editor), 'background-color'); |
||
| 11447 | }, |
||
| 11448 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11449 | }); |
||
| 11450 | editor.ui.registry.addNestedMenuItem('tablecellbordercolor', { |
||
| 11451 | icon: 'cell-border-color', |
||
| 11452 | text: 'Border color', |
||
| 11453 | getSubmenuItems: function () { |
||
| 11454 | return buildColorMenu(editor, getTableBorderColorMap(editor), 'border-color'); |
||
| 11455 | }, |
||
| 11456 | onSetup: selectionTargets.onSetupCellOrRow |
||
| 11457 | }); |
||
| 11458 | editor.ui.registry.addToggleMenuItem('tablerowheader', { |
||
| 11459 | text: 'Row header', |
||
| 11460 | icon: 'table-top-header', |
||
| 11461 | onAction: changeRowHeader(editor), |
||
| 11462 | onSetup: selectionTargets.onSetupTableRowHeaders |
||
| 11463 | }); |
||
| 11464 | editor.ui.registry.addToggleMenuItem('tablecolheader', { |
||
| 11465 | text: 'Column header', |
||
| 11466 | icon: 'table-left-header', |
||
| 11467 | onAction: changeColumnHeader(editor), |
||
| 11468 | onSetup: selectionTargets.onSetupTableColumnHeaders |
||
| 11469 | }); |
||
| 597 | daniel-mar | 11470 | }; |
| 11471 | |||
| 11472 | var Plugin = function (editor) { |
||
| 11473 | var selections = Selections(function () { |
||
| 637 | daniel-mar | 11474 | return getBody(editor); |
| 597 | daniel-mar | 11475 | }, function () { |
| 637 | daniel-mar | 11476 | return getSelectionCell(getSelectionStart(editor), getIsRoot(editor)); |
| 597 | daniel-mar | 11477 | }, ephemera.selectedSelector); |
| 11478 | var selectionTargets = getSelectionTargets(editor, selections); |
||
| 11479 | var resizeHandler = getResizeHandler(editor); |
||
| 11480 | var cellSelection = CellSelection(editor, resizeHandler.lazyResize, selectionTargets); |
||
| 637 | daniel-mar | 11481 | var actions = TableActions(editor, cellSelection, resizeHandler.lazyWire); |
| 597 | daniel-mar | 11482 | var clipboard = Clipboard(); |
| 11483 | registerCommands(editor, actions, cellSelection, selections, clipboard); |
||
| 11484 | registerQueryCommands(editor, actions, selections); |
||
| 637 | daniel-mar | 11485 | registerEvents(editor, selections, actions); |
| 11486 | addMenuItems(editor, selections, selectionTargets, clipboard); |
||
| 11487 | addButtons(editor, selections, selectionTargets, clipboard); |
||
| 597 | daniel-mar | 11488 | addToolbars(editor); |
| 11489 | editor.on('PreInit', function () { |
||
| 11490 | editor.serializer.addTempAttr(ephemera.firstSelected); |
||
| 11491 | editor.serializer.addTempAttr(ephemera.lastSelected); |
||
| 11492 | registerFormats(editor); |
||
| 11493 | }); |
||
| 11494 | if (hasTabNavigation(editor)) { |
||
| 11495 | editor.on('keydown', function (e) { |
||
| 11496 | handle$1(e, editor, cellSelection); |
||
| 11497 | }); |
||
| 11498 | } |
||
| 11499 | editor.on('remove', function () { |
||
| 11500 | resizeHandler.destroy(); |
||
| 11501 | }); |
||
| 11502 | return getApi(editor, clipboard, resizeHandler, selectionTargets); |
||
| 11503 | }; |
||
| 11504 | function Plugin$1 () { |
||
| 637 | daniel-mar | 11505 | global$3.add('table', Plugin); |
| 597 | daniel-mar | 11506 | } |
| 11507 | |||
| 11508 | Plugin$1(); |
||
| 11509 | |||
| 11510 | }()); |