WebSVN – oidplus – Blame – /trunk/vendor/tinymce/tinymce/plugins/image/plugin.js

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
679	daniel-mar	12	var global$6 = tinymce.util.Tools.resolve('tinymce.PluginManager');
597	daniel-mar	13
		14	var __assign = function () {
		15	__assign = Object.assign \|\| function __assign(t) {
		16	for (var s, i = 1, n = arguments.length; i < n; i++) {
		17	s = arguments[i];
		18	for (var p in s)
		19	if (Object.prototype.hasOwnProperty.call(s, p))
		20	t[p] = s[p];
		21	}
		22	return t;
		23	};
		24	return __assign.apply(this, arguments);
		25	};
		26
		27	var typeOf = function (x) {
		28	var t = typeof x;
		29	if (x === null) {
		30	return 'null';
		31	} else if (t === 'object' && (Array.prototype.isPrototypeOf(x) \|\| x.constructor && x.constructor.name === 'Array')) {
		32	return 'array';
		33	} else if (t === 'object' && (String.prototype.isPrototypeOf(x) \|\| x.constructor && x.constructor.name === 'String')) {
		34	return 'string';
		35	} else {
		36	return t;
		37	}
		38	};
		39	var isType = function (type) {
		40	return function (value) {
		41	return typeOf(value) === type;
		42	};
		43	};
		44	var isSimpleType = function (type) {
		45	return function (value) {
		46	return typeof value === type;
		47	};
		48	};
		49	var eq = function (t) {
		50	return function (a) {
		51	return t === a;
		52	};
		53	};
		54	var isString = isType('string');
		55	var isObject = isType('object');
		56	var isArray = isType('array');
		57	var isNull = eq(null);
		58	var isBoolean = isSimpleType('boolean');
		59	var isNullable = function (a) {
		60	return a === null \|\| a === undefined;
		61	};
		62	var isNonNullable = function (a) {
		63	return !isNullable(a);
		64	};
637	daniel-mar	65	var isFunction = isSimpleType('function');
597	daniel-mar	66	var isNumber = isSimpleType('number');
		67
		68	var noop = function () {
		69	};
		70	var constant = function (value) {
		71	return function () {
		72	return value;
		73	};
		74	};
637	daniel-mar	75	var identity = function (x) {
		76	return x;
		77	};
597	daniel-mar	78	var never = constant(false);
		79	var always = constant(true);
		80
		81	var none = function () {
		82	return NONE;
		83	};
		84	var NONE = function () {
		85	var call = function (thunk) {
		86	return thunk();
		87	};
637	daniel-mar	88	var id = identity;
597	daniel-mar	89	var me = {
		90	fold: function (n, _s) {
		91	return n();
		92	},
		93	isSome: never,
		94	isNone: always,
		95	getOr: id,
		96	getOrThunk: call,
		97	getOrDie: function (msg) {
		98	throw new Error(msg \|\| 'error: getOrDie called on none.');
		99	},
		100	getOrNull: constant(null),
		101	getOrUndefined: constant(undefined),
		102	or: id,
		103	orThunk: call,
		104	map: none,
		105	each: noop,
		106	bind: none,
		107	exists: never,
		108	forall: always,
637	daniel-mar	109	filter: function () {
		110	return none();
		111	},
597	daniel-mar	112	toArray: function () {
		113	return [];
		114	},
		115	toString: constant('none()')
		116	};
		117	return me;
		118	}();
		119	var some = function (a) {
		120	var constant_a = constant(a);
		121	var self = function () {
		122	return me;
		123	};
		124	var bind = function (f) {
		125	return f(a);
		126	};
		127	var me = {
		128	fold: function (n, s) {
		129	return s(a);
		130	},
		131	isSome: always,
		132	isNone: never,
		133	getOr: constant_a,
		134	getOrThunk: constant_a,
		135	getOrDie: constant_a,
		136	getOrNull: constant_a,
		137	getOrUndefined: constant_a,
		138	or: self,
		139	orThunk: self,
		140	map: function (f) {
		141	return some(f(a));
		142	},
		143	each: function (f) {
		144	f(a);
		145	},
		146	bind: bind,
		147	exists: bind,
		148	forall: bind,
		149	filter: function (f) {
		150	return f(a) ? me : NONE;
		151	},
		152	toArray: function () {
		153	return [a];
		154	},
		155	toString: function () {
		156	return 'some(' + a + ')';
		157	}
		158	};
		159	return me;
		160	};
		161	var from = function (value) {
		162	return value === null \|\| value === undefined ? NONE : some(value);
		163	};
		164	var Optional = {
		165	some: some,
		166	none: none,
		167	from: from
		168	};
		169
		170	var keys = Object.keys;
		171	var hasOwnProperty = Object.hasOwnProperty;
		172	var each = function (obj, f) {
		173	var props = keys(obj);
		174	for (var k = 0, len = props.length; k < len; k++) {
		175	var i = props[k];
		176	var x = obj[i];
		177	f(x, i);
		178	}
		179	};
		180	var objAcc = function (r) {
		181	return function (x, i) {
		182	r[i] = x;
		183	};
		184	};
		185	var internalFilter = function (obj, pred, onTrue, onFalse) {
		186	var r = {};
		187	each(obj, function (x, i) {
		188	(pred(x, i) ? onTrue : onFalse)(x, i);
		189	});
		190	return r;
		191	};
		192	var filter = function (obj, pred) {
		193	var t = {};
		194	internalFilter(obj, pred, objAcc(t), noop);
		195	return t;
		196	};
		197	var has = function (obj, key) {
		198	return hasOwnProperty.call(obj, key);
		199	};
		200	var hasNonNullableKey = function (obj, key) {
		201	return has(obj, key) && obj[key] !== undefined && obj[key] !== null;
		202	};
		203
		204	var nativePush = Array.prototype.push;
		205	var flatten = function (xs) {
		206	var r = [];
		207	for (var i = 0, len = xs.length; i < len; ++i) {
		208	if (!isArray(xs[i])) {
		209	throw new Error('Arr.flatten item ' + i + ' was not an array, input: ' + xs);
		210	}
		211	nativePush.apply(r, xs[i]);
		212	}
		213	return r;
		214	};
		215	var get = function (xs, i) {
		216	return i >= 0 && i < xs.length ? Optional.some(xs[i]) : Optional.none();
		217	};
		218	var head = function (xs) {
		219	return get(xs, 0);
		220	};
		221	var findMap = function (arr, f) {
		222	for (var i = 0; i < arr.length; i++) {
		223	var r = f(arr[i], i);
		224	if (r.isSome()) {
		225	return r;
		226	}
		227	}
		228	return Optional.none();
		229	};
		230
637	daniel-mar	231	typeof window !== 'undefined' ? window : Function('return this;')();
597	daniel-mar	232
		233	var rawSet = function (dom, key, value) {
		234	if (isString(value) \|\| isBoolean(value) \|\| isNumber(value)) {
		235	dom.setAttribute(key, value + '');
		236	} else {
		237	console.error('Invalid call to Attribute.set. Key ', key, ':: Value ', value, ':: Element ', dom);
		238	throw new Error('Attribute value was not simple');
		239	}
		240	};
		241	var set = function (element, key, value) {
		242	rawSet(element.dom, key, value);
		243	};
		244	var remove = function (element, key) {
		245	element.dom.removeAttribute(key);
		246	};
		247
		248	var fromHtml = function (html, scope) {
		249	var doc = scope \|\| document;
		250	var div = doc.createElement('div');
		251	div.innerHTML = html;
		252	if (!div.hasChildNodes() \|\| div.childNodes.length > 1) {
		253	console.error('HTML does not have a single root node', html);
		254	throw new Error('HTML must have a single root node');
		255	}
		256	return fromDom(div.childNodes[0]);
		257	};
		258	var fromTag = function (tag, scope) {
		259	var doc = scope \|\| document;
		260	var node = doc.createElement(tag);
		261	return fromDom(node);
		262	};
		263	var fromText = function (text, scope) {
		264	var doc = scope \|\| document;
		265	var node = doc.createTextNode(text);
		266	return fromDom(node);
		267	};
		268	var fromDom = function (node) {
		269	if (node === null \|\| node === undefined) {
		270	throw new Error('Node cannot be null or undefined');
		271	}
		272	return { dom: node };
		273	};
		274	var fromPoint = function (docElm, x, y) {
		275	return Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom);
		276	};
		277	var SugarElement = {
		278	fromHtml: fromHtml,
		279	fromTag: fromTag,
		280	fromText: fromText,
		281	fromDom: fromDom,
		282	fromPoint: fromPoint
		283	};
		284
679	daniel-mar	285	var global$5 = tinymce.util.Tools.resolve('tinymce.dom.DOMUtils');
597	daniel-mar	286
679	daniel-mar	287	var global$4 = tinymce.util.Tools.resolve('tinymce.util.Promise');
597	daniel-mar	288
679	daniel-mar	289	var global$3 = tinymce.util.Tools.resolve('tinymce.util.URI');
		290
637	daniel-mar	291	var global$2 = tinymce.util.Tools.resolve('tinymce.util.XHR');
597	daniel-mar	292
		293	var hasDimensions = function (editor) {
		294	return editor.getParam('image_dimensions', true, 'boolean');
		295	};
		296	var hasAdvTab = function (editor) {
		297	return editor.getParam('image_advtab', false, 'boolean');
		298	};
		299	var hasUploadTab = function (editor) {
		300	return editor.getParam('image_uploadtab', true, 'boolean');
		301	};
		302	var getPrependUrl = function (editor) {
		303	return editor.getParam('image_prepend_url', '', 'string');
		304	};
		305	var getClassList = function (editor) {
		306	return editor.getParam('image_class_list');
		307	};
		308	var hasDescription = function (editor) {
		309	return editor.getParam('image_description', true, 'boolean');
		310	};
		311	var hasImageTitle = function (editor) {
		312	return editor.getParam('image_title', false, 'boolean');
		313	};
		314	var hasImageCaption = function (editor) {
		315	return editor.getParam('image_caption', false, 'boolean');
		316	};
		317	var getImageList = function (editor) {
		318	return editor.getParam('image_list', false);
		319	};
		320	var hasUploadUrl = function (editor) {
		321	return isNonNullable(editor.getParam('images_upload_url'));
		322	};
		323	var hasUploadHandler = function (editor) {
		324	return isNonNullable(editor.getParam('images_upload_handler'));
		325	};
		326	var showAccessibilityOptions = function (editor) {
		327	return editor.getParam('a11y_advanced_options', false, 'boolean');
		328	};
		329	var isAutomaticUploadsEnabled = function (editor) {
		330	return editor.getParam('automatic_uploads', true, 'boolean');
		331	};
		332
		333	var parseIntAndGetMax = function (val1, val2) {
		334	return Math.max(parseInt(val1, 10), parseInt(val2, 10));
		335	};
		336	var getImageSize = function (url) {
679	daniel-mar	337	return new global$4(function (callback) {
597	daniel-mar	338	var img = document.createElement('img');
		339	var done = function (dimensions) {
637	daniel-mar	340	img.onload = img.onerror = null;
597	daniel-mar	341	if (img.parentNode) {
		342	img.parentNode.removeChild(img);
		343	}
		344	callback(dimensions);
		345	};
		346	img.onload = function () {
		347	var width = parseIntAndGetMax(img.width, img.clientWidth);
		348	var height = parseIntAndGetMax(img.height, img.clientHeight);
		349	var dimensions = {
		350	width: width,
		351	height: height
		352	};
679	daniel-mar	353	done(global$4.resolve(dimensions));
597	daniel-mar	354	};
		355	img.onerror = function () {
679	daniel-mar	356	done(global$4.reject('Failed to get image dimensions for: ' + url));
597	daniel-mar	357	};
		358	var style = img.style;
		359	style.visibility = 'hidden';
		360	style.position = 'fixed';
		361	style.bottom = style.left = '0px';
		362	style.width = style.height = 'auto';
		363	document.body.appendChild(img);
		364	img.src = url;
		365	});
		366	};
		367	var removePixelSuffix = function (value) {
		368	if (value) {
		369	value = value.replace(/px$/, '');
		370	}
		371	return value;
		372	};
		373	var addPixelSuffix = function (value) {
		374	if (value.length > 0 && /^[0-9]+$/.test(value)) {
		375	value += 'px';
		376	}
		377	return value;
		378	};
		379	var mergeMargins = function (css) {
		380	if (css.margin) {
		381	var splitMargin = String(css.margin).split(' ');
		382	switch (splitMargin.length) {
		383	case 1:
		384	css['margin-top'] = css['margin-top'] \|\| splitMargin[0];
		385	css['margin-right'] = css['margin-right'] \|\| splitMargin[0];
		386	css['margin-bottom'] = css['margin-bottom'] \|\| splitMargin[0];
		387	css['margin-left'] = css['margin-left'] \|\| splitMargin[0];
		388	break;
		389	case 2:
		390	css['margin-top'] = css['margin-top'] \|\| splitMargin[0];
		391	css['margin-right'] = css['margin-right'] \|\| splitMargin[1];
		392	css['margin-bottom'] = css['margin-bottom'] \|\| splitMargin[0];
		393	css['margin-left'] = css['margin-left'] \|\| splitMargin[1];
		394	break;
		395	case 3:
		396	css['margin-top'] = css['margin-top'] \|\| splitMargin[0];
		397	css['margin-right'] = css['margin-right'] \|\| splitMargin[1];
		398	css['margin-bottom'] = css['margin-bottom'] \|\| splitMargin[2];
		399	css['margin-left'] = css['margin-left'] \|\| splitMargin[1];
		400	break;
		401	case 4:
		402	css['margin-top'] = css['margin-top'] \|\| splitMargin[0];
		403	css['margin-right'] = css['margin-right'] \|\| splitMargin[1];
		404	css['margin-bottom'] = css['margin-bottom'] \|\| splitMargin[2];
		405	css['margin-left'] = css['margin-left'] \|\| splitMargin[3];
		406	}
		407	delete css.margin;
		408	}
		409	return css;
		410	};
		411	var createImageList = function (editor, callback) {
		412	var imageList = getImageList(editor);
637	daniel-mar	413	if (isString(imageList)) {
		414	global$2.send({
597	daniel-mar	415	url: imageList,
		416	success: function (text) {
		417	callback(JSON.parse(text));
		418	}
		419	});
637	daniel-mar	420	} else if (isFunction(imageList)) {
597	daniel-mar	421	imageList(callback);
		422	} else {
		423	callback(imageList);
		424	}
		425	};
		426	var waitLoadImage = function (editor, data, imgElm) {
		427	var selectImage = function () {
		428	imgElm.onload = imgElm.onerror = null;
		429	if (editor.selection) {
		430	editor.selection.select(imgElm);
		431	editor.nodeChanged();
		432	}
		433	};
		434	imgElm.onload = function () {
		435	if (!data.width && !data.height && hasDimensions(editor)) {
		436	editor.dom.setAttribs(imgElm, {
		437	width: String(imgElm.clientWidth),
		438	height: String(imgElm.clientHeight)
		439	});
		440	}
		441	selectImage();
		442	};
		443	imgElm.onerror = selectImage;
		444	};
		445	var blobToDataUri = function (blob) {
679	daniel-mar	446	return new global$4(function (resolve, reject) {
597	daniel-mar	447	var reader = new FileReader();
		448	reader.onload = function () {
		449	resolve(reader.result);
		450	};
		451	reader.onerror = function () {
		452	reject(reader.error.message);
		453	};
		454	reader.readAsDataURL(blob);
		455	});
		456	};
		457	var isPlaceholderImage = function (imgElm) {
		458	return imgElm.nodeName === 'IMG' && (imgElm.hasAttribute('data-mce-object') \|\| imgElm.hasAttribute('data-mce-placeholder'));
		459	};
679	daniel-mar	460	var isSafeImageUrl = function (editor, src) {
		461	return global$3.isDomSafe(src, 'img', editor.settings);
		462	};
597	daniel-mar	463
679	daniel-mar	464	var DOM = global$5.DOM;
597	daniel-mar	465	var getHspace = function (image) {
		466	if (image.style.marginLeft && image.style.marginRight && image.style.marginLeft === image.style.marginRight) {
		467	return removePixelSuffix(image.style.marginLeft);
		468	} else {
		469	return '';
		470	}
		471	};
		472	var getVspace = function (image) {
		473	if (image.style.marginTop && image.style.marginBottom && image.style.marginTop === image.style.marginBottom) {
		474	return removePixelSuffix(image.style.marginTop);
		475	} else {
		476	return '';
		477	}
		478	};
		479	var getBorder = function (image) {
		480	if (image.style.borderWidth) {
		481	return removePixelSuffix(image.style.borderWidth);
		482	} else {
		483	return '';
		484	}
		485	};
		486	var getAttrib = function (image, name) {
		487	if (image.hasAttribute(name)) {
		488	return image.getAttribute(name);
		489	} else {
		490	return '';
		491	}
		492	};
		493	var getStyle = function (image, name) {
		494	return image.style[name] ? image.style[name] : '';
		495	};
		496	var hasCaption = function (image) {
		497	return image.parentNode !== null && image.parentNode.nodeName === 'FIGURE';
		498	};
		499	var updateAttrib = function (image, name, value) {
		500	if (value === '') {
		501	image.removeAttribute(name);
		502	} else {
		503	image.setAttribute(name, value);
		504	}
		505	};
		506	var wrapInFigure = function (image) {
		507	var figureElm = DOM.create('figure', { class: 'image' });
		508	DOM.insertAfter(figureElm, image);
		509	figureElm.appendChild(image);
		510	figureElm.appendChild(DOM.create('figcaption', { contentEditable: 'true' }, 'Caption'));
		511	figureElm.contentEditable = 'false';
		512	};
		513	var removeFigure = function (image) {
		514	var figureElm = image.parentNode;
		515	DOM.insertAfter(image, figureElm);
		516	DOM.remove(figureElm);
		517	};
		518	var toggleCaption = function (image) {
		519	if (hasCaption(image)) {
		520	removeFigure(image);
		521	} else {
		522	wrapInFigure(image);
		523	}
		524	};
		525	var normalizeStyle = function (image, normalizeCss) {
		526	var attrValue = image.getAttribute('style');
		527	var value = normalizeCss(attrValue !== null ? attrValue : '');
		528	if (value.length > 0) {
		529	image.setAttribute('style', value);
		530	image.setAttribute('data-mce-style', value);
		531	} else {
		532	image.removeAttribute('style');
		533	}
		534	};
		535	var setSize = function (name, normalizeCss) {
		536	return function (image, name, value) {
		537	if (image.style[name]) {
		538	image.style[name] = addPixelSuffix(value);
		539	normalizeStyle(image, normalizeCss);
		540	} else {
		541	updateAttrib(image, name, value);
		542	}
		543	};
		544	};
		545	var getSize = function (image, name) {
		546	if (image.style[name]) {
		547	return removePixelSuffix(image.style[name]);
		548	} else {
		549	return getAttrib(image, name);
		550	}
		551	};
		552	var setHspace = function (image, value) {
		553	var pxValue = addPixelSuffix(value);
		554	image.style.marginLeft = pxValue;
		555	image.style.marginRight = pxValue;
		556	};
		557	var setVspace = function (image, value) {
		558	var pxValue = addPixelSuffix(value);
		559	image.style.marginTop = pxValue;
		560	image.style.marginBottom = pxValue;
		561	};
		562	var setBorder = function (image, value) {
		563	var pxValue = addPixelSuffix(value);
		564	image.style.borderWidth = pxValue;
		565	};
		566	var setBorderStyle = function (image, value) {
		567	image.style.borderStyle = value;
		568	};
		569	var getBorderStyle = function (image) {
		570	return getStyle(image, 'borderStyle');
		571	};
		572	var isFigure = function (elm) {
		573	return elm.nodeName === 'FIGURE';
		574	};
		575	var isImage = function (elm) {
		576	return elm.nodeName === 'IMG';
		577	};
		578	var getIsDecorative = function (image) {
		579	return DOM.getAttrib(image, 'alt').length === 0 && DOM.getAttrib(image, 'role') === 'presentation';
		580	};
		581	var getAlt = function (image) {
		582	if (getIsDecorative(image)) {
		583	return '';
		584	} else {
		585	return getAttrib(image, 'alt');
		586	}
		587	};
		588	var defaultData = function () {
		589	return {
		590	src: '',
		591	alt: '',
		592	title: '',
		593	width: '',
		594	height: '',
		595	class: '',
		596	style: '',
		597	caption: false,
		598	hspace: '',
		599	vspace: '',
		600	border: '',
		601	borderStyle: '',
		602	isDecorative: false
		603	};
		604	};
		605	var getStyleValue = function (normalizeCss, data) {
		606	var image = document.createElement('img');
		607	updateAttrib(image, 'style', data.style);
		608	if (getHspace(image) \|\| data.hspace !== '') {
		609	setHspace(image, data.hspace);
		610	}
		611	if (getVspace(image) \|\| data.vspace !== '') {
		612	setVspace(image, data.vspace);
		613	}
		614	if (getBorder(image) \|\| data.border !== '') {
		615	setBorder(image, data.border);
		616	}
		617	if (getBorderStyle(image) \|\| data.borderStyle !== '') {
		618	setBorderStyle(image, data.borderStyle);
		619	}
		620	return normalizeCss(image.getAttribute('style'));
		621	};
		622	var create = function (normalizeCss, data) {
		623	var image = document.createElement('img');
		624	write(normalizeCss, __assign(__assign({}, data), { caption: false }), image);
		625	setAlt(image, data.alt, data.isDecorative);
		626	if (data.caption) {
		627	var figure = DOM.create('figure', { class: 'image' });
		628	figure.appendChild(image);
		629	figure.appendChild(DOM.create('figcaption', { contentEditable: 'true' }, 'Caption'));
		630	figure.contentEditable = 'false';
		631	return figure;
		632	} else {
		633	return image;
		634	}
		635	};
		636	var read = function (normalizeCss, image) {
		637	return {
		638	src: getAttrib(image, 'src'),
		639	alt: getAlt(image),
		640	title: getAttrib(image, 'title'),
		641	width: getSize(image, 'width'),
		642	height: getSize(image, 'height'),
		643	class: getAttrib(image, 'class'),
		644	style: normalizeCss(getAttrib(image, 'style')),
		645	caption: hasCaption(image),
		646	hspace: getHspace(image),
		647	vspace: getVspace(image),
		648	border: getBorder(image),
		649	borderStyle: getStyle(image, 'borderStyle'),
		650	isDecorative: getIsDecorative(image)
		651	};
		652	};
		653	var updateProp = function (image, oldData, newData, name, set) {
		654	if (newData[name] !== oldData[name]) {
		655	set(image, name, newData[name]);
		656	}
		657	};
		658	var setAlt = function (image, alt, isDecorative) {
		659	if (isDecorative) {
		660	DOM.setAttrib(image, 'role', 'presentation');
		661	var sugarImage = SugarElement.fromDom(image);
		662	set(sugarImage, 'alt', '');
		663	} else {
		664	if (isNull(alt)) {
		665	var sugarImage = SugarElement.fromDom(image);
		666	remove(sugarImage, 'alt');
		667	} else {
		668	var sugarImage = SugarElement.fromDom(image);
		669	set(sugarImage, 'alt', alt);
		670	}
		671	if (DOM.getAttrib(image, 'role') === 'presentation') {
		672	DOM.setAttrib(image, 'role', '');
		673	}
		674	}
		675	};
		676	var updateAlt = function (image, oldData, newData) {
		677	if (newData.alt !== oldData.alt \|\| newData.isDecorative !== oldData.isDecorative) {
		678	setAlt(image, newData.alt, newData.isDecorative);
		679	}
		680	};
		681	var normalized = function (set, normalizeCss) {
		682	return function (image, name, value) {
		683	set(image, value);
		684	normalizeStyle(image, normalizeCss);
		685	};
		686	};
		687	var write = function (normalizeCss, newData, image) {
		688	var oldData = read(normalizeCss, image);
		689	updateProp(image, oldData, newData, 'caption', function (image, _name, _value) {
		690	return toggleCaption(image);
		691	});
		692	updateProp(image, oldData, newData, 'src', updateAttrib);
		693	updateProp(image, oldData, newData, 'title', updateAttrib);
		694	updateProp(image, oldData, newData, 'width', setSize('width', normalizeCss));
		695	updateProp(image, oldData, newData, 'height', setSize('height', normalizeCss));
		696	updateProp(image, oldData, newData, 'class', updateAttrib);
		697	updateProp(image, oldData, newData, 'style', normalized(function (image, value) {
		698	return updateAttrib(image, 'style', value);
		699	}, normalizeCss));
		700	updateProp(image, oldData, newData, 'hspace', normalized(setHspace, normalizeCss));
		701	updateProp(image, oldData, newData, 'vspace', normalized(setVspace, normalizeCss));
		702	updateProp(image, oldData, newData, 'border', normalized(setBorder, normalizeCss));
		703	updateProp(image, oldData, newData, 'borderStyle', normalized(setBorderStyle, normalizeCss));
		704	updateAlt(image, oldData, newData);
		705	};
		706
637	daniel-mar	707	var normalizeCss$1 = function (editor, cssText) {
597	daniel-mar	708	var css = editor.dom.styles.parse(cssText);
		709	var mergedCss = mergeMargins(css);
		710	var compressed = editor.dom.styles.parse(editor.dom.styles.serialize(mergedCss));
		711	return editor.dom.styles.serialize(compressed);
		712	};
		713	var getSelectedImage = function (editor) {
		714	var imgElm = editor.selection.getNode();
		715	var figureElm = editor.dom.getParent(imgElm, 'figure.image');
		716	if (figureElm) {
		717	return editor.dom.select('img', figureElm)[0];
		718	}
		719	if (imgElm && (imgElm.nodeName !== 'IMG' \|\| isPlaceholderImage(imgElm))) {
		720	return null;
		721	}
		722	return imgElm;
		723	};
		724	var splitTextBlock = function (editor, figure) {
		725	var dom = editor.dom;
		726	var textBlockElements = filter(editor.schema.getTextBlockElements(), function (_, parentElm) {
		727	return !editor.schema.isValidChild(parentElm, 'figure');
		728	});
		729	var textBlock = dom.getParent(figure.parentNode, function (node) {
		730	return hasNonNullableKey(textBlockElements, node.nodeName);
		731	}, editor.getBody());
		732	if (textBlock) {
		733	return dom.split(textBlock, figure);
		734	} else {
		735	return figure;
		736	}
		737	};
		738	var readImageDataFromSelection = function (editor) {
		739	var image = getSelectedImage(editor);
		740	return image ? read(function (css) {
637	daniel-mar	741	return normalizeCss$1(editor, css);
597	daniel-mar	742	}, image) : defaultData();
		743	};
		744	var insertImageAtCaret = function (editor, data) {
		745	var elm = create(function (css) {
637	daniel-mar	746	return normalizeCss$1(editor, css);
597	daniel-mar	747	}, data);
		748	editor.dom.setAttrib(elm, 'data-mce-id', '__mcenew');
		749	editor.focus();
		750	editor.selection.setContent(elm.outerHTML);
		751	var insertedElm = editor.dom.select('*[data-mce-id="__mcenew"]')[0];
		752	editor.dom.setAttrib(insertedElm, 'data-mce-id', null);
		753	if (isFigure(insertedElm)) {
		754	var figure = splitTextBlock(editor, insertedElm);
		755	editor.selection.select(figure);
		756	} else {
		757	editor.selection.select(insertedElm);
		758	}
		759	};
		760	var syncSrcAttr = function (editor, image) {
		761	editor.dom.setAttrib(image, 'src', image.getAttribute('src'));
		762	};
		763	var deleteImage = function (editor, image) {
		764	if (image) {
		765	var elm = editor.dom.is(image.parentNode, 'figure.image') ? image.parentNode : image;
		766	editor.dom.remove(elm);
		767	editor.focus();
		768	editor.nodeChanged();
		769	if (editor.dom.isEmpty(editor.getBody())) {
		770	editor.setContent('');
		771	editor.selection.setCursorLocation();
		772	}
		773	}
		774	};
		775	var writeImageDataToSelection = function (editor, data) {
		776	var image = getSelectedImage(editor);
		777	write(function (css) {
637	daniel-mar	778	return normalizeCss$1(editor, css);
597	daniel-mar	779	}, data, image);
		780	syncSrcAttr(editor, image);
		781	if (isFigure(image.parentNode)) {
		782	var figure = image.parentNode;
		783	splitTextBlock(editor, figure);
		784	editor.selection.select(image.parentNode);
		785	} else {
		786	editor.selection.select(image);
		787	waitLoadImage(editor, data, image);
		788	}
		789	};
679	daniel-mar	790	var sanitizeImageData = function (editor, data) {
		791	var src = data.src;
		792	return __assign(__assign({}, data), { src: isSafeImageUrl(editor, src) ? src : '' });
		793	};
597	daniel-mar	794	var insertOrUpdateImage = function (editor, partialData) {
		795	var image = getSelectedImage(editor);
		796	if (image) {
		797	var selectedImageData = read(function (css) {
637	daniel-mar	798	return normalizeCss$1(editor, css);
597	daniel-mar	799	}, image);
		800	var data = __assign(__assign({}, selectedImageData), partialData);
679	daniel-mar	801	var sanitizedData = sanitizeImageData(editor, data);
597	daniel-mar	802	if (data.src) {
679	daniel-mar	803	writeImageDataToSelection(editor, sanitizedData);
597	daniel-mar	804	} else {
		805	deleteImage(editor, image);
		806	}
		807	} else if (partialData.src) {
		808	insertImageAtCaret(editor, __assign(__assign({}, defaultData()), partialData));
		809	}
		810	};
		811
		812	var deep = function (old, nu) {
		813	var bothObjects = isObject(old) && isObject(nu);
		814	return bothObjects ? deepMerge(old, nu) : nu;
		815	};
		816	var baseMerge = function (merger) {
		817	return function () {
		818	var objects = [];
		819	for (var _i = 0; _i < arguments.length; _i++) {
		820	objects[_i] = arguments[_i];
		821	}
		822	if (objects.length === 0) {
		823	throw new Error('Can\'t merge zero objects');
		824	}
		825	var ret = {};
		826	for (var j = 0; j < objects.length; j++) {
		827	var curObject = objects[j];
		828	for (var key in curObject) {
637	daniel-mar	829	if (has(curObject, key)) {
597	daniel-mar	830	ret[key] = merger(ret[key], curObject[key]);
		831	}
		832	}
		833	}
		834	return ret;
		835	};
		836	};
		837	var deepMerge = baseMerge(deep);
		838
		839	var isNotEmpty = function (s) {
		840	return s.length > 0;
		841	};
		842
637	daniel-mar	843	var global$1 = tinymce.util.Tools.resolve('tinymce.util.ImageUploader');
597	daniel-mar	844
637	daniel-mar	845	var global = tinymce.util.Tools.resolve('tinymce.util.Tools');
597	daniel-mar	846
		847	var getValue = function (item) {
		848	return isString(item.value) ? item.value : '';
		849	};
		850	var getText = function (item) {
		851	if (isString(item.text)) {
		852	return item.text;
		853	} else if (isString(item.title)) {
		854	return item.title;
		855	} else {
		856	return '';
		857	}
		858	};
		859	var sanitizeList = function (list, extractValue) {
		860	var out = [];
637	daniel-mar	861	global.each(list, function (item) {
597	daniel-mar	862	var text = getText(item);
		863	if (item.menu !== undefined) {
		864	var items = sanitizeList(item.menu, extractValue);
		865	out.push({
		866	text: text,
		867	items: items
		868	});
		869	} else {
		870	var value = extractValue(item);
		871	out.push({
		872	text: text,
		873	value: value
		874	});
		875	}
		876	});
		877	return out;
		878	};
637	daniel-mar	879	var sanitizer = function (extractor) {
		880	if (extractor === void 0) {
		881	extractor = getValue;
597	daniel-mar	882	}
		883	return function (list) {
		884	if (list) {
		885	return Optional.from(list).map(function (list) {
637	daniel-mar	886	return sanitizeList(list, extractor);
597	daniel-mar	887	});
		888	} else {
		889	return Optional.none();
		890	}
		891	};
		892	};
		893	var sanitize = function (list) {
		894	return sanitizer(getValue)(list);
		895	};
		896	var isGroup = function (item) {
637	daniel-mar	897	return has(item, 'items');
597	daniel-mar	898	};
		899	var findEntryDelegate = function (list, value) {
		900	return findMap(list, function (item) {
		901	if (isGroup(item)) {
		902	return findEntryDelegate(item.items, value);
		903	} else if (item.value === value) {
		904	return Optional.some(item);
		905	} else {
		906	return Optional.none();
		907	}
		908	});
		909	};
		910	var findEntry = function (optList, value) {
		911	return optList.bind(function (list) {
		912	return findEntryDelegate(list, value);
		913	});
		914	};
		915	var ListUtils = {
		916	sanitizer: sanitizer,
		917	sanitize: sanitize,
		918	findEntry: findEntry
		919	};
		920
637	daniel-mar	921	var makeTab$2 = function (_info) {
597	daniel-mar	922	return {
		923	title: 'Advanced',
		924	name: 'advanced',
		925	items: [
		926	{
		927	type: 'input',
		928	label: 'Style',
		929	name: 'style'
		930	},
		931	{
		932	type: 'grid',
		933	columns: 2,
		934	items: [
		935	{
		936	type: 'input',
		937	label: 'Vertical space',
		938	name: 'vspace',
		939	inputMode: 'numeric'
		940	},
		941	{
		942	type: 'input',
		943	label: 'Horizontal space',
		944	name: 'hspace',
		945	inputMode: 'numeric'
		946	},
		947	{
		948	type: 'input',
		949	label: 'Border width',
		950	name: 'border',
		951	inputMode: 'numeric'
		952	},
		953	{
		954	type: 'listbox',
		955	name: 'borderstyle',
		956	label: 'Border style',
		957	items: [
		958	{
		959	text: 'Select...',
		960	value: ''
		961	},
		962	{
		963	text: 'Solid',
		964	value: 'solid'
		965	},
		966	{
		967	text: 'Dotted',
		968	value: 'dotted'
		969	},
		970	{
		971	text: 'Dashed',
		972	value: 'dashed'
		973	},
		974	{
		975	text: 'Double',
		976	value: 'double'
		977	},
		978	{
		979	text: 'Groove',
		980	value: 'groove'
		981	},
		982	{
		983	text: 'Ridge',
		984	value: 'ridge'
		985	},
		986	{
		987	text: 'Inset',
		988	value: 'inset'
		989	},
		990	{
		991	text: 'Outset',
		992	value: 'outset'
		993	},
		994	{
		995	text: 'None',
		996	value: 'none'
		997	},
		998	{
		999	text: 'Hidden',
		1000	value: 'hidden'
		1001	}
		1002	]
		1003	}
		1004	]
		1005	}
		1006	]
		1007	};
		1008	};
637	daniel-mar	1009	var AdvTab = { makeTab: makeTab$2 };
597	daniel-mar	1010
		1011	var collect = function (editor) {
		1012	var urlListSanitizer = ListUtils.sanitizer(function (item) {
		1013	return editor.convertURL(item.value \|\| item.url, 'src');
		1014	});
679	daniel-mar	1015	var futureImageList = new global$4(function (completer) {
597	daniel-mar	1016	createImageList(editor, function (imageList) {
		1017	completer(urlListSanitizer(imageList).map(function (items) {
		1018	return flatten([
		1019	[{
		1020	text: 'None',
		1021	value: ''
		1022	}],
		1023	items
		1024	]);
		1025	}));
		1026	});
		1027	});
		1028	var classList = ListUtils.sanitize(getClassList(editor));
		1029	var hasAdvTab$1 = hasAdvTab(editor);
		1030	var hasUploadTab$1 = hasUploadTab(editor);
		1031	var hasUploadUrl$1 = hasUploadUrl(editor);
		1032	var hasUploadHandler$1 = hasUploadHandler(editor);
		1033	var image = readImageDataFromSelection(editor);
		1034	var hasDescription$1 = hasDescription(editor);
		1035	var hasImageTitle$1 = hasImageTitle(editor);
		1036	var hasDimensions$1 = hasDimensions(editor);
		1037	var hasImageCaption$1 = hasImageCaption(editor);
		1038	var hasAccessibilityOptions = showAccessibilityOptions(editor);
		1039	var automaticUploads = isAutomaticUploadsEnabled(editor);
		1040	var prependURL = Optional.some(getPrependUrl(editor)).filter(function (preUrl) {
		1041	return isString(preUrl) && preUrl.length > 0;
		1042	});
		1043	return futureImageList.then(function (imageList) {
		1044	return {
		1045	image: image,
		1046	imageList: imageList,
		1047	classList: classList,
		1048	hasAdvTab: hasAdvTab$1,
		1049	hasUploadTab: hasUploadTab$1,
		1050	hasUploadUrl: hasUploadUrl$1,
		1051	hasUploadHandler: hasUploadHandler$1,
		1052	hasDescription: hasDescription$1,
		1053	hasImageTitle: hasImageTitle$1,
		1054	hasDimensions: hasDimensions$1,
		1055	hasImageCaption: hasImageCaption$1,
		1056	prependURL: prependURL,
		1057	hasAccessibilityOptions: hasAccessibilityOptions,
		1058	automaticUploads: automaticUploads
		1059	};
		1060	});
		1061	};
		1062
		1063	var makeItems = function (info) {
		1064	var imageUrl = {
		1065	name: 'src',
		1066	type: 'urlinput',
		1067	filetype: 'image',
		1068	label: 'Source'
		1069	};
		1070	var imageList = info.imageList.map(function (items) {
		1071	return {
		1072	name: 'images',
		1073	type: 'listbox',
		1074	label: 'Image list',
		1075	items: items
		1076	};
		1077	});
		1078	var imageDescription = {
		1079	name: 'alt',
		1080	type: 'input',
		1081	label: 'Alternative description',
		1082	disabled: info.hasAccessibilityOptions && info.image.isDecorative
		1083	};
		1084	var imageTitle = {
		1085	name: 'title',
		1086	type: 'input',
		1087	label: 'Image title'
		1088	};
		1089	var imageDimensions = {
		1090	name: 'dimensions',
		1091	type: 'sizeinput'
		1092	};
		1093	var isDecorative = {
		1094	type: 'label',
		1095	label: 'Accessibility',
		1096	items: [{
		1097	name: 'isDecorative',
		1098	type: 'checkbox',
		1099	label: 'Image is decorative'
		1100	}]
		1101	};
		1102	var classList = info.classList.map(function (items) {
		1103	return {
		1104	name: 'classes',
		1105	type: 'listbox',
		1106	label: 'Class',
		1107	items: items
		1108	};
		1109	});
		1110	var caption = {
		1111	type: 'label',
		1112	label: 'Caption',
		1113	items: [{
		1114	type: 'checkbox',
		1115	name: 'caption',
		1116	label: 'Show caption'
		1117	}]
		1118	};
		1119	var getDialogContainerType = function (useColumns) {
		1120	return useColumns ? {
		1121	type: 'grid',
		1122	columns: 2
		1123	} : { type: 'panel' };
		1124	};
		1125	return flatten([
		1126	[imageUrl],
		1127	imageList.toArray(),
		1128	info.hasAccessibilityOptions && info.hasDescription ? [isDecorative] : [],
		1129	info.hasDescription ? [imageDescription] : [],
		1130	info.hasImageTitle ? [imageTitle] : [],
		1131	info.hasDimensions ? [imageDimensions] : [],
		1132	[__assign(__assign({}, getDialogContainerType(info.classList.isSome() && info.hasImageCaption)), {
		1133	items: flatten([
		1134	classList.toArray(),
		1135	info.hasImageCaption ? [caption] : []
		1136	])
		1137	})]
		1138	]);
		1139	};
		1140	var makeTab$1 = function (info) {
		1141	return {
		1142	title: 'General',
		1143	name: 'general',
		1144	items: makeItems(info)
		1145	};
		1146	};
		1147	var MainTab = {
		1148	makeTab: makeTab$1,
		1149	makeItems: makeItems
		1150	};
		1151
637	daniel-mar	1152	var makeTab = function (_info) {
597	daniel-mar	1153	var items = [{
		1154	type: 'dropzone',
		1155	name: 'fileinput'
		1156	}];
		1157	return {
		1158	title: 'Upload',
		1159	name: 'upload',
		1160	items: items
		1161	};
		1162	};
637	daniel-mar	1163	var UploadTab = { makeTab: makeTab };
597	daniel-mar	1164
		1165	var createState = function (info) {
		1166	return {
		1167	prevImage: ListUtils.findEntry(info.imageList, info.image.src),
		1168	prevAlt: info.image.alt,
		1169	open: true
		1170	};
		1171	};
		1172	var fromImageData = function (image) {
		1173	return {
		1174	src: {
		1175	value: image.src,
		1176	meta: {}
		1177	},
		1178	images: image.src,
		1179	alt: image.alt,
		1180	title: image.title,
		1181	dimensions: {
		1182	width: image.width,
		1183	height: image.height
		1184	},
		1185	classes: image.class,
		1186	caption: image.caption,
		1187	style: image.style,
		1188	vspace: image.vspace,
		1189	border: image.border,
		1190	hspace: image.hspace,
		1191	borderstyle: image.borderStyle,
		1192	fileinput: [],
		1193	isDecorative: image.isDecorative
		1194	};
		1195	};
		1196	var toImageData = function (data, removeEmptyAlt) {
		1197	return {
		1198	src: data.src.value,
		1199	alt: data.alt.length === 0 && removeEmptyAlt ? null : data.alt,
		1200	title: data.title,
		1201	width: data.dimensions.width,
		1202	height: data.dimensions.height,
		1203	class: data.classes,
		1204	style: data.style,
		1205	caption: data.caption,
		1206	hspace: data.hspace,
		1207	vspace: data.vspace,
		1208	border: data.border,
		1209	borderStyle: data.borderstyle,
		1210	isDecorative: data.isDecorative
		1211	};
		1212	};
		1213	var addPrependUrl2 = function (info, srcURL) {
		1214	if (!/^(?:[a-zA-Z]+:)?\/\//.test(srcURL)) {
		1215	return info.prependURL.bind(function (prependUrl) {
		1216	if (srcURL.substring(0, prependUrl.length) !== prependUrl) {
		1217	return Optional.some(prependUrl + srcURL);
		1218	}
		1219	return Optional.none();
		1220	});
		1221	}
		1222	return Optional.none();
		1223	};
		1224	var addPrependUrl = function (info, api) {
		1225	var data = api.getData();
		1226	addPrependUrl2(info, data.src.value).each(function (srcURL) {
		1227	api.setData({
		1228	src: {
		1229	value: srcURL,
		1230	meta: data.src.meta
		1231	}
		1232	});
		1233	});
		1234	};
		1235	var formFillFromMeta2 = function (info, data, meta) {
		1236	if (info.hasDescription && isString(meta.alt)) {
		1237	data.alt = meta.alt;
		1238	}
		1239	if (info.hasAccessibilityOptions) {
		1240	data.isDecorative = meta.isDecorative \|\| data.isDecorative \|\| false;
		1241	}
		1242	if (info.hasImageTitle && isString(meta.title)) {
		1243	data.title = meta.title;
		1244	}
		1245	if (info.hasDimensions) {
		1246	if (isString(meta.width)) {
		1247	data.dimensions.width = meta.width;
		1248	}
		1249	if (isString(meta.height)) {
		1250	data.dimensions.height = meta.height;
		1251	}
		1252	}
		1253	if (isString(meta.class)) {
		1254	ListUtils.findEntry(info.classList, meta.class).each(function (entry) {
		1255	data.classes = entry.value;
		1256	});
		1257	}
		1258	if (info.hasImageCaption) {
		1259	if (isBoolean(meta.caption)) {
		1260	data.caption = meta.caption;
		1261	}
		1262	}
		1263	if (info.hasAdvTab) {
		1264	if (isString(meta.style)) {
		1265	data.style = meta.style;
		1266	}
		1267	if (isString(meta.vspace)) {
		1268	data.vspace = meta.vspace;
		1269	}
		1270	if (isString(meta.border)) {
		1271	data.border = meta.border;
		1272	}
		1273	if (isString(meta.hspace)) {
		1274	data.hspace = meta.hspace;
		1275	}
		1276	if (isString(meta.borderstyle)) {
		1277	data.borderstyle = meta.borderstyle;
		1278	}
		1279	}
		1280	};
		1281	var formFillFromMeta = function (info, api) {
		1282	var data = api.getData();
		1283	var meta = data.src.meta;
		1284	if (meta !== undefined) {
		1285	var newData = deepMerge({}, data);
		1286	formFillFromMeta2(info, newData, meta);
		1287	api.setData(newData);
		1288	}
		1289	};
		1290	var calculateImageSize = function (helpers, info, state, api) {
		1291	var data = api.getData();
		1292	var url = data.src.value;
		1293	var meta = data.src.meta \|\| {};
		1294	if (!meta.width && !meta.height && info.hasDimensions) {
		1295	if (isNotEmpty(url)) {
		1296	helpers.imageSize(url).then(function (size) {
		1297	if (state.open) {
		1298	api.setData({ dimensions: size });
		1299	}
		1300	}).catch(function (e) {
		1301	return console.error(e);
		1302	});
		1303	} else {
		1304	api.setData({
		1305	dimensions: {
		1306	width: '',
		1307	height: ''
		1308	}
		1309	});
		1310	}
		1311	}
		1312	};
		1313	var updateImagesDropdown = function (info, state, api) {
		1314	var data = api.getData();
		1315	var image = ListUtils.findEntry(info.imageList, data.src.value);
		1316	state.prevImage = image;
		1317	api.setData({
		1318	images: image.map(function (entry) {
		1319	return entry.value;
		1320	}).getOr('')
		1321	});
		1322	};
		1323	var changeSrc = function (helpers, info, state, api) {
		1324	addPrependUrl(info, api);
		1325	formFillFromMeta(info, api);
		1326	calculateImageSize(helpers, info, state, api);
		1327	updateImagesDropdown(info, state, api);
		1328	};
		1329	var changeImages = function (helpers, info, state, api) {
		1330	var data = api.getData();
		1331	var image = ListUtils.findEntry(info.imageList, data.images);
		1332	image.each(function (img) {
		1333	var updateAlt = data.alt === '' \|\| state.prevImage.map(function (image) {
		1334	return image.text === data.alt;
		1335	}).getOr(false);
		1336	if (updateAlt) {
		1337	if (img.value === '') {
		1338	api.setData({
		1339	src: img,
		1340	alt: state.prevAlt
		1341	});
		1342	} else {
		1343	api.setData({
		1344	src: img,
		1345	alt: img.text
		1346	});
		1347	}
		1348	} else {
		1349	api.setData({ src: img });
		1350	}
		1351	});
		1352	state.prevImage = image;
		1353	changeSrc(helpers, info, state, api);
		1354	};
		1355	var calcVSpace = function (css) {
		1356	var matchingTopBottom = css['margin-top'] && css['margin-bottom'] && css['margin-top'] === css['margin-bottom'];
		1357	return matchingTopBottom ? removePixelSuffix(String(css['margin-top'])) : '';
		1358	};
		1359	var calcHSpace = function (css) {
		1360	var matchingLeftRight = css['margin-right'] && css['margin-left'] && css['margin-right'] === css['margin-left'];
		1361	return matchingLeftRight ? removePixelSuffix(String(css['margin-right'])) : '';
		1362	};
		1363	var calcBorderWidth = function (css) {
		1364	return css['border-width'] ? removePixelSuffix(String(css['border-width'])) : '';
		1365	};
		1366	var calcBorderStyle = function (css) {
		1367	return css['border-style'] ? String(css['border-style']) : '';
		1368	};
		1369	var calcStyle = function (parseStyle, serializeStyle, css) {
		1370	return serializeStyle(parseStyle(serializeStyle(css)));
		1371	};
		1372	var changeStyle2 = function (parseStyle, serializeStyle, data) {
		1373	var css = mergeMargins(parseStyle(data.style));
		1374	var dataCopy = deepMerge({}, data);
		1375	dataCopy.vspace = calcVSpace(css);
		1376	dataCopy.hspace = calcHSpace(css);
		1377	dataCopy.border = calcBorderWidth(css);
		1378	dataCopy.borderstyle = calcBorderStyle(css);
		1379	dataCopy.style = calcStyle(parseStyle, serializeStyle, css);
		1380	return dataCopy;
		1381	};
		1382	var changeStyle = function (helpers, api) {
		1383	var data = api.getData();
		1384	var newData = changeStyle2(helpers.parseStyle, helpers.serializeStyle, data);
		1385	api.setData(newData);
		1386	};
		1387	var changeAStyle = function (helpers, info, api) {
		1388	var data = deepMerge(fromImageData(info.image), api.getData());
		1389	var style = getStyleValue(helpers.normalizeCss, toImageData(data, false));
		1390	api.setData({ style: style });
		1391	};
		1392	var changeFileInput = function (helpers, info, state, api) {
		1393	var data = api.getData();
		1394	api.block('Uploading image');
		1395	head(data.fileinput).fold(function () {
		1396	api.unblock();
		1397	}, function (file) {
		1398	var blobUri = URL.createObjectURL(file);
		1399	var finalize = function () {
		1400	api.unblock();
		1401	URL.revokeObjectURL(blobUri);
		1402	};
		1403	var updateSrcAndSwitchTab = function (url) {
		1404	api.setData({
		1405	src: {
		1406	value: url,
		1407	meta: {}
		1408	}
		1409	});
		1410	api.showTab('general');
		1411	changeSrc(helpers, info, state, api);
		1412	};
		1413	blobToDataUri(file).then(function (dataUrl) {
		1414	var blobInfo = helpers.createBlobCache(file, blobUri, dataUrl);
		1415	if (info.automaticUploads) {
		1416	helpers.uploadImage(blobInfo).then(function (result) {
		1417	updateSrcAndSwitchTab(result.url);
		1418	finalize();
		1419	}).catch(function (err) {
		1420	finalize();
		1421	helpers.alertErr(err);
		1422	});
		1423	} else {
		1424	helpers.addToBlobCache(blobInfo);
		1425	updateSrcAndSwitchTab(blobInfo.blobUri());
		1426	api.unblock();
		1427	}
		1428	});
		1429	});
		1430	};
		1431	var changeHandler = function (helpers, info, state) {
		1432	return function (api, evt) {
		1433	if (evt.name === 'src') {
		1434	changeSrc(helpers, info, state, api);
		1435	} else if (evt.name === 'images') {
		1436	changeImages(helpers, info, state, api);
		1437	} else if (evt.name === 'alt') {
		1438	state.prevAlt = api.getData().alt;
		1439	} else if (evt.name === 'style') {
		1440	changeStyle(helpers, api);
		1441	} else if (evt.name === 'vspace' \|\| evt.name === 'hspace' \|\| evt.name === 'border' \|\| evt.name === 'borderstyle') {
		1442	changeAStyle(helpers, info, api);
		1443	} else if (evt.name === 'fileinput') {
		1444	changeFileInput(helpers, info, state, api);
		1445	} else if (evt.name === 'isDecorative') {
		1446	if (api.getData().isDecorative) {
		1447	api.disable('alt');
		1448	} else {
		1449	api.enable('alt');
		1450	}
		1451	}
		1452	};
		1453	};
		1454	var closeHandler = function (state) {
		1455	return function () {
		1456	state.open = false;
		1457	};
		1458	};
		1459	var makeDialogBody = function (info) {
		1460	if (info.hasAdvTab \|\| info.hasUploadUrl \|\| info.hasUploadHandler) {
		1461	var tabPanel = {
		1462	type: 'tabpanel',
		1463	tabs: flatten([
		1464	[MainTab.makeTab(info)],
		1465	info.hasAdvTab ? [AdvTab.makeTab(info)] : [],
		1466	info.hasUploadTab && (info.hasUploadUrl \|\| info.hasUploadHandler) ? [UploadTab.makeTab(info)] : []
		1467	])
		1468	};
		1469	return tabPanel;
		1470	} else {
		1471	var panel = {
		1472	type: 'panel',
		1473	items: MainTab.makeItems(info)
		1474	};
		1475	return panel;
		1476	}
		1477	};
		1478	var makeDialog = function (helpers) {
		1479	return function (info) {
		1480	var state = createState(info);
		1481	return {
		1482	title: 'Insert/Edit Image',
		1483	size: 'normal',
		1484	body: makeDialogBody(info),
		1485	buttons: [
		1486	{
		1487	type: 'cancel',
		1488	name: 'cancel',
		1489	text: 'Cancel'
		1490	},
		1491	{
		1492	type: 'submit',
		1493	name: 'save',
		1494	text: 'Save',
		1495	primary: true
		1496	}
		1497	],
		1498	initialData: fromImageData(info.image),
		1499	onSubmit: helpers.onSubmit(info),
		1500	onChange: changeHandler(helpers, info, state),
		1501	onClose: closeHandler(state)
		1502	};
		1503	};
		1504	};
		1505	var submitHandler = function (editor) {
		1506	return function (info) {
		1507	return function (api) {
		1508	var data = deepMerge(fromImageData(info.image), api.getData());
		1509	editor.execCommand('mceUpdateImage', false, toImageData(data, info.hasAccessibilityOptions));
		1510	editor.editorUpload.uploadImagesAuto();
		1511	api.close();
		1512	};
		1513	};
		1514	};
		1515	var imageSize = function (editor) {
		1516	return function (url) {
679	daniel-mar	1517	if (!isSafeImageUrl(editor, url)) {
		1518	return global$4.resolve({
		1519	width: '',
		1520	height: ''
		1521	});
		1522	} else {
		1523	return getImageSize(editor.documentBaseURI.toAbsolute(url)).then(function (dimensions) {
		1524	return {
		1525	width: String(dimensions.width),
		1526	height: String(dimensions.height)
		1527	};
		1528	});
		1529	}
597	daniel-mar	1530	};
		1531	};
		1532	var createBlobCache = function (editor) {
		1533	return function (file, blobUri, dataUrl) {
		1534	return editor.editorUpload.blobCache.create({
		1535	blob: file,
		1536	blobUri: blobUri,
		1537	name: file.name ? file.name.replace(/\.[^\.]+$/, '') : null,
		1538	filename: file.name,
		1539	base64: dataUrl.split(',')[1]
		1540	});
		1541	};
		1542	};
		1543	var addToBlobCache = function (editor) {
		1544	return function (blobInfo) {
		1545	editor.editorUpload.blobCache.add(blobInfo);
		1546	};
		1547	};
		1548	var alertErr = function (editor) {
		1549	return function (message) {
		1550	editor.windowManager.alert(message);
		1551	};
		1552	};
637	daniel-mar	1553	var normalizeCss = function (editor) {
597	daniel-mar	1554	return function (cssText) {
637	daniel-mar	1555	return normalizeCss$1(editor, cssText);
597	daniel-mar	1556	};
		1557	};
		1558	var parseStyle = function (editor) {
		1559	return function (cssText) {
		1560	return editor.dom.parseStyle(cssText);
		1561	};
		1562	};
		1563	var serializeStyle = function (editor) {
		1564	return function (stylesArg, name) {
		1565	return editor.dom.serializeStyle(stylesArg, name);
		1566	};
		1567	};
		1568	var uploadImage = function (editor) {
		1569	return function (blobInfo) {
637	daniel-mar	1570	return global$1(editor).upload([blobInfo], false).then(function (results) {
597	daniel-mar	1571	if (results.length === 0) {
679	daniel-mar	1572	return global$4.reject('Failed to upload image');
597	daniel-mar	1573	} else if (results[0].status === false) {
679	daniel-mar	1574	return global$4.reject(results[0].error.message);
597	daniel-mar	1575	} else {
		1576	return results[0];
		1577	}
		1578	});
		1579	};
		1580	};
		1581	var Dialog = function (editor) {
		1582	var helpers = {
		1583	onSubmit: submitHandler(editor),
		1584	imageSize: imageSize(editor),
		1585	addToBlobCache: addToBlobCache(editor),
		1586	createBlobCache: createBlobCache(editor),
		1587	alertErr: alertErr(editor),
637	daniel-mar	1588	normalizeCss: normalizeCss(editor),
597	daniel-mar	1589	parseStyle: parseStyle(editor),
		1590	serializeStyle: serializeStyle(editor),
		1591	uploadImage: uploadImage(editor)
		1592	};
		1593	var open = function () {
		1594	collect(editor).then(makeDialog(helpers)).then(editor.windowManager.open);
		1595	};
		1596	return { open: open };
		1597	};
		1598
637	daniel-mar	1599	var register$1 = function (editor) {
597	daniel-mar	1600	editor.addCommand('mceImage', Dialog(editor).open);
		1601	editor.addCommand('mceUpdateImage', function (_ui, data) {
		1602	editor.undoManager.transact(function () {
		1603	return insertOrUpdateImage(editor, data);
		1604	});
		1605	});
		1606	};
		1607
		1608	var hasImageClass = function (node) {
		1609	var className = node.attr('class');
		1610	return className && /\bimage\b/.test(className);
		1611	};
		1612	var toggleContentEditableState = function (state) {
		1613	return function (nodes) {
		1614	var i = nodes.length;
		1615	var toggleContentEditable = function (node) {
		1616	node.attr('contenteditable', state ? 'true' : null);
		1617	};
		1618	while (i--) {
		1619	var node = nodes[i];
		1620	if (hasImageClass(node)) {
		1621	node.attr('contenteditable', state ? 'false' : null);
637	daniel-mar	1622	global.each(node.getAll('figcaption'), toggleContentEditable);
597	daniel-mar	1623	}
		1624	}
		1625	};
		1626	};
		1627	var setup = function (editor) {
		1628	editor.on('PreInit', function () {
		1629	editor.parser.addNodeFilter('figure', toggleContentEditableState(true));
		1630	editor.serializer.addNodeFilter('figure', toggleContentEditableState(false));
		1631	});
		1632	};
		1633
637	daniel-mar	1634	var register = function (editor) {
597	daniel-mar	1635	editor.ui.registry.addToggleButton('image', {
		1636	icon: 'image',
		1637	tooltip: 'Insert/edit image',
		1638	onAction: Dialog(editor).open,
		1639	onSetup: function (buttonApi) {
679	daniel-mar	1640	buttonApi.setActive(isNonNullable(getSelectedImage(editor)));
597	daniel-mar	1641	return editor.selection.selectorChangedWithUnbind('img:not([data-mce-object],[data-mce-placeholder]),figure.image', buttonApi.setActive).unbind;
		1642	}
		1643	});
		1644	editor.ui.registry.addMenuItem('image', {
		1645	icon: 'image',
		1646	text: 'Image...',
		1647	onAction: Dialog(editor).open
		1648	});
		1649	editor.ui.registry.addContextMenu('image', {
		1650	update: function (element) {
		1651	return isFigure(element) \|\| isImage(element) && !isPlaceholderImage(element) ? ['image'] : [];
		1652	}
		1653	});
		1654	};
		1655
		1656	function Plugin () {
679	daniel-mar	1657	global$6.add('image', function (editor) {
597	daniel-mar	1658	setup(editor);
637	daniel-mar	1659	register(editor);
597	daniel-mar	1660	register$1(editor);
		1661	});
		1662	}
		1663
		1664	Plugin();
		1665
		1666	}());

Subversion Repositories oidplus

oidplus/trunk/vendor/tinymce/tinymce/plugins/image/plugin.js – Rev 1422