964 lines
28 KiB
JavaScript
964 lines
28 KiB
JavaScript
/* global dirtyReporter showHelp prefs ignoreChromeError
|
|
CodeMirror propertyToCss
|
|
regExpTester linter createLivePreview showCodeMirrorPopup
|
|
sectionsToMozFormat messageBox clipString beautify
|
|
rerouteHotkeys cmFactory CssToProperty template $ $$ $create t FIREFOX API
|
|
debounce tryRegExp
|
|
*/
|
|
/* exported createSectionsEditor */
|
|
'use strict';
|
|
|
|
function createResizeGrip(cm) {
|
|
const wrapper = cm.display.wrapper;
|
|
wrapper.classList.add('resize-grip-enabled');
|
|
const resizeGrip = template.resizeGrip.cloneNode(true);
|
|
wrapper.appendChild(resizeGrip);
|
|
let lastClickTime = 0;
|
|
resizeGrip.onmousedown = event => {
|
|
if (event.button !== 0) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
if (Date.now() - lastClickTime < 500) {
|
|
lastClickTime = 0;
|
|
toggleSectionHeight(cm);
|
|
return;
|
|
}
|
|
lastClickTime = Date.now();
|
|
const minHeight = cm.defaultTextHeight() +
|
|
/* .CodeMirror-lines padding */
|
|
cm.display.lineDiv.offsetParent.offsetTop +
|
|
/* borders */
|
|
wrapper.offsetHeight - wrapper.clientHeight;
|
|
wrapper.style.pointerEvents = 'none';
|
|
document.body.style.cursor = 's-resize';
|
|
document.addEventListener('mousemove', resize);
|
|
document.addEventListener('mouseup', resizeStop);
|
|
|
|
function resize(e) {
|
|
const cmPageY = wrapper.getBoundingClientRect().top + window.scrollY;
|
|
const height = Math.max(minHeight, e.pageY - cmPageY);
|
|
if (height !== wrapper.clientHeight) {
|
|
cm.setSize(null, height);
|
|
}
|
|
}
|
|
|
|
function resizeStop() {
|
|
document.removeEventListener('mouseup', resizeStop);
|
|
document.removeEventListener('mousemove', resize);
|
|
wrapper.style.pointerEvents = '';
|
|
document.body.style.cursor = '';
|
|
}
|
|
};
|
|
|
|
function toggleSectionHeight(cm) {
|
|
if (cm.state.toggleHeightSaved) {
|
|
// restore previous size
|
|
cm.setSize(null, cm.state.toggleHeightSaved);
|
|
cm.state.toggleHeightSaved = 0;
|
|
} else {
|
|
// maximize
|
|
const wrapper = cm.display.wrapper;
|
|
const allBounds = $('#sections').getBoundingClientRect();
|
|
const pageExtrasHeight = allBounds.top + window.scrollY +
|
|
parseFloat(getComputedStyle($('#sections')).paddingBottom);
|
|
const sectionEl = wrapper.parentNode;
|
|
const sectionExtrasHeight = sectionEl.clientHeight - wrapper.offsetHeight;
|
|
cm.state.toggleHeightSaved = wrapper.clientHeight;
|
|
cm.setSize(null, window.innerHeight - sectionExtrasHeight - pageExtrasHeight);
|
|
const bounds = sectionEl.getBoundingClientRect();
|
|
if (bounds.top < 0 || bounds.bottom > window.innerHeight) {
|
|
window.scrollBy(0, bounds.top);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function createSectionsEditor(style) {
|
|
let INC_ID = 0; // an increment id that is used by various object to track the order
|
|
const dirty = dirtyReporter();
|
|
dirty.onChange(updateTitle);
|
|
|
|
const container = $('#sections');
|
|
const sections = [];
|
|
|
|
const nameEl = $('#name');
|
|
nameEl.addEventListener('change', () => {
|
|
dirty.modify('name', style.name, nameEl.value);
|
|
style.name = nameEl.value;
|
|
});
|
|
|
|
const enabledEl = $('#enabled');
|
|
enabledEl.addEventListener('change', () => {
|
|
dirty.modify('enabled', style.enabled, enabledEl.checked);
|
|
style.enabled = enabledEl.checked;
|
|
updateLivePreview();
|
|
});
|
|
|
|
$('#to-mozilla').addEventListener('click', showMozillaFormat);
|
|
$('#to-mozilla-help').addEventListener('click', showToMozillaHelp);
|
|
$('#from-mozilla').addEventListener('click', () => fromMozillaFormat());
|
|
$('#save-button').addEventListener('click', saveStyle);
|
|
// FIXME: this element doesn't exist?
|
|
$('#sections-help').addEventListener('click', showSectionHelp);
|
|
|
|
document.addEventListener('wheel', scrollEntirePageOnCtrlShift);
|
|
|
|
if (!FIREFOX) {
|
|
$$([
|
|
'input:not([type])',
|
|
'input[type="text"]',
|
|
'input[type="search"]',
|
|
'input[type="number"]',
|
|
].join(','))
|
|
.forEach(e => e.addEventListener('mousedown', toggleContextMenuDelete));
|
|
}
|
|
|
|
let sectionOrder = '';
|
|
const initializing = new Promise(resolve => initSection({
|
|
sections: style.sections.slice(),
|
|
done:() => {
|
|
// FIXME: implement this with CSS?
|
|
// https://github.com/openstyles/stylus/commit/2895ce11e271788df0e4f7314b3b981fde086574
|
|
dirty.clear();
|
|
rerouteHotkeys(true);
|
|
resolve();
|
|
updateHeader();
|
|
}
|
|
}));
|
|
|
|
const livePreview = createLivePreview();
|
|
livePreview.show(Boolean(style.id));
|
|
|
|
return {
|
|
ready: () => initializing,
|
|
replaceStyle,
|
|
isDirty: dirty.isDirty,
|
|
getStyle: () => style,
|
|
getEditors,
|
|
scrollToEditor,
|
|
getStyleId: () => style.id,
|
|
getEditorTitle: cm => {
|
|
const index = sections.filter(s => !s.isRemoved()).findIndex(s => s.cm === cm);
|
|
return `${t('sectionCode')} ${index + 1}`;
|
|
},
|
|
save: saveStyle,
|
|
toggleStyle,
|
|
nextEditor,
|
|
prevEditor,
|
|
closestVisible,
|
|
getSearchableInputs,
|
|
};
|
|
|
|
function toggleContextMenuDelete(event) {
|
|
if (chrome.contextMenus && event.button === 2 && prefs.get('editor.contextDelete')) {
|
|
chrome.contextMenus.update('editor.contextDelete', {
|
|
enabled: Boolean(
|
|
this.selectionStart !== this.selectionEnd ||
|
|
this.somethingSelected && this.somethingSelected()
|
|
),
|
|
}, ignoreChromeError);
|
|
}
|
|
}
|
|
|
|
function setGlobalProgress(done, total) {
|
|
const progressElement = $('#global-progress') ||
|
|
total && document.body.appendChild($create('#global-progress'));
|
|
if (total) {
|
|
const progress = (done / Math.max(done, total) * 100).toFixed(1);
|
|
progressElement.style.borderLeftWidth = progress + 'vw';
|
|
setTimeout(() => {
|
|
progressElement.title = progress + '%';
|
|
});
|
|
} else {
|
|
$.remove(progressElement);
|
|
}
|
|
}
|
|
|
|
function showToMozillaHelp(event) {
|
|
event.preventDefault();
|
|
showHelp(t('styleMozillaFormatHeading'), t('styleToMozillaFormatHelp'));
|
|
}
|
|
|
|
function showAppliesToHelp(event) {
|
|
event.preventDefault();
|
|
showHelp(t('appliesLabel'), t('appliesHelp'));
|
|
}
|
|
|
|
function showSectionHelp(event) {
|
|
event.preventDefault();
|
|
showHelp(t('styleSectionsTitle'), t('sectionHelp'));
|
|
}
|
|
|
|
function getSearchableInputs(cm) {
|
|
return sections.find(s => s.cm === cm).appliesTo.map(a => a.valueEl).filter(Boolean);
|
|
}
|
|
|
|
// priority:
|
|
// 1. associated CM for applies-to element
|
|
// 2. last active if visible
|
|
// 3. first visible
|
|
function closestVisible(nearbyElement) {
|
|
const cm =
|
|
nearbyElement instanceof CodeMirror ? nearbyElement :
|
|
nearbyElement instanceof Node &&
|
|
(nearbyElement.closest('#sections > .section') || {}).CodeMirror ||
|
|
getLastActivatedEditor();
|
|
console.log(cm);
|
|
if (nearbyElement instanceof Node && cm) {
|
|
const {left, top} = nearbyElement.getBoundingClientRect();
|
|
const bounds = cm.display.wrapper.getBoundingClientRect();
|
|
if (top >= 0 && top >= bounds.top &&
|
|
left >= 0 && left >= bounds.left) {
|
|
return cm;
|
|
}
|
|
}
|
|
// closest editor should have at least 2 lines visible
|
|
const lineHeight = sections[0].cm.defaultTextHeight();
|
|
const scrollY = window.scrollY;
|
|
const windowBottom = scrollY + window.innerHeight - 2 * lineHeight;
|
|
const allSectionsContainerTop = scrollY + $('#sections').getBoundingClientRect().top;
|
|
const distances = [];
|
|
const alreadyInView = cm && offscreenDistance(null, cm) === 0;
|
|
return alreadyInView ? cm : findClosest();
|
|
|
|
function offscreenDistance(index, cm) {
|
|
if (index >= 0 && distances[index] !== undefined) {
|
|
return distances[index];
|
|
}
|
|
const section = cm.display.wrapper.closest('.section');
|
|
if (!section) {
|
|
return 1e9;
|
|
}
|
|
const top = allSectionsContainerTop + section.offsetTop;
|
|
if (top < scrollY + lineHeight) {
|
|
return Math.max(0, scrollY - top - lineHeight);
|
|
}
|
|
if (top < windowBottom) {
|
|
return 0;
|
|
}
|
|
const distance = top - windowBottom + section.offsetHeight;
|
|
if (index >= 0) {
|
|
distances[index] = distance;
|
|
}
|
|
return distance;
|
|
}
|
|
|
|
function findClosest() {
|
|
const editors = getEditors();
|
|
const last = editors.length - 1;
|
|
let a = 0;
|
|
let b = last;
|
|
let c;
|
|
let distance;
|
|
while (a < b - 1) {
|
|
c = (a + b) / 2 | 0;
|
|
distance = offscreenDistance(c);
|
|
if (!distance || !c) {
|
|
break;
|
|
}
|
|
const distancePrev = offscreenDistance(c - 1);
|
|
const distanceNext = c < last ? offscreenDistance(c + 1) : 1e20;
|
|
if (distancePrev <= distance && distance <= distanceNext) {
|
|
b = c;
|
|
} else {
|
|
a = c;
|
|
}
|
|
}
|
|
while (b && offscreenDistance(b - 1) <= offscreenDistance(b)) {
|
|
b--;
|
|
}
|
|
const cm = editors[b];
|
|
if (distances[b] > 0) {
|
|
scrollToEditor(cm);
|
|
}
|
|
return cm;
|
|
}
|
|
}
|
|
|
|
function getEditors() {
|
|
return sections.filter(s => !s.isRemoved()).map(s => s.cm);
|
|
}
|
|
|
|
function toggleStyle() {
|
|
const newValue = !style.enabled;
|
|
dirty.modify('enabled', style.enabled, newValue);
|
|
style.enabled = newValue;
|
|
enabledEl.checked = newValue;
|
|
}
|
|
|
|
function nextEditor(cm) {
|
|
return nextPrevEditor(cm, 1);
|
|
}
|
|
|
|
function prevEditor(cm) {
|
|
return nextPrevEditor(cm, -1);
|
|
}
|
|
|
|
function nextPrevEditor(cm, direction) {
|
|
const editors = getEditors();
|
|
cm = editors[(editors.indexOf(cm) + direction + editors.length) % editors.length];
|
|
scrollToEditor(cm);
|
|
cm.focus();
|
|
return cm;
|
|
}
|
|
|
|
function scrollToEditor(cm) {
|
|
const section = sections.find(s => s.cm === cm).el;
|
|
const bounds = section.getBoundingClientRect();
|
|
if (
|
|
(bounds.bottom > window.innerHeight && bounds.top > 0) ||
|
|
(bounds.top < 0 && bounds.bottom < window.innerHeight)
|
|
) {
|
|
if (bounds.top < 0) {
|
|
window.scrollBy(0, bounds.top - 1);
|
|
} else {
|
|
window.scrollBy(0, bounds.bottom - window.innerHeight + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
function getLastActivatedEditor() {
|
|
let result;
|
|
for (const section of sections) {
|
|
if (section.isRemoved()) {
|
|
continue;
|
|
}
|
|
// .lastActive is initiated by codemirror-factory
|
|
if (!result || section.cm.lastActive > result.lastActive) {
|
|
result = section.cm;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function nextPrevEditorOnKeydown(cm, event) {
|
|
const key = event.which;
|
|
if (key < 37 || key > 40 || event.shiftKey || event.altKey || event.metaKey) {
|
|
return;
|
|
}
|
|
const {line, ch} = cm.getCursor();
|
|
switch (key) {
|
|
case 37:
|
|
// arrow Left
|
|
if (line || ch) {
|
|
return;
|
|
}
|
|
// fallthrough to arrow Up
|
|
case 38:
|
|
// arrow Up
|
|
if (line > 0 || cm === sections[0].cm) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
cm = prevEditor(cm);
|
|
cm.setCursor(cm.doc.size - 1, key === 37 ? 1e20 : ch);
|
|
break;
|
|
case 39:
|
|
// arrow Right
|
|
if (line < cm.doc.size - 1 || ch < cm.getLine(line).length - 1) {
|
|
return;
|
|
}
|
|
// fallthrough to arrow Down
|
|
case 40:
|
|
// arrow Down
|
|
if (line < cm.doc.size - 1 || cm === sections[sections.length - 1].cm) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
cm = nextEditor(cm);
|
|
cm.setCursor(0, 0);
|
|
break;
|
|
}
|
|
// FIXME: what is this?
|
|
// const animation = (cm.getSection().firstElementChild.getAnimations() || [])[0];
|
|
// if (animation) {
|
|
// animation.playbackRate = -1;
|
|
// animation.currentTime = 2000;
|
|
// animation.play();
|
|
// }
|
|
}
|
|
|
|
function scrollEntirePageOnCtrlShift(event) {
|
|
// make Shift-Ctrl-Wheel scroll entire page even when mouse is over a code editor
|
|
if (event.shiftKey && event.ctrlKey && !event.altKey && !event.metaKey) {
|
|
// Chrome scrolls horizontally when Shift is pressed but on some PCs this might be different
|
|
window.scrollBy(0, event.deltaX || event.deltaY);
|
|
event.preventDefault();
|
|
}
|
|
}
|
|
|
|
function showMozillaFormat() {
|
|
const popup = showCodeMirrorPopup(t('styleToMozillaFormatTitle'), '', {readOnly: true});
|
|
popup.codebox.setValue(sectionsToMozFormat(getModel()));
|
|
popup.codebox.execCommand('selectAll');
|
|
}
|
|
|
|
function fromMozillaFormat(text = '') {
|
|
const popup = showCodeMirrorPopup(t('styleFromMozillaFormatPrompt'),
|
|
$create('.buttons', [
|
|
$create('button', {
|
|
name: 'import-replace',
|
|
textContent: t('importReplaceLabel'),
|
|
title: 'Ctrl-Shift-Enter:\n' + t('importReplaceTooltip'),
|
|
onclick: () => doImport({replaceOldStyle: true}),
|
|
}),
|
|
$create('button', {
|
|
name: 'import-append',
|
|
textContent: t('importAppendLabel'),
|
|
title: 'Ctrl-Enter:\n' + t('importAppendTooltip'),
|
|
onclick: doImport,
|
|
}),
|
|
]));
|
|
const contents = $('.contents', popup);
|
|
contents.insertBefore(popup.codebox.display.wrapper, contents.firstElementChild);
|
|
popup.codebox.focus();
|
|
popup.codebox.on('changes', cm => {
|
|
popup.classList.toggle('ready', !cm.isBlank());
|
|
cm.markClean();
|
|
});
|
|
if (text) {
|
|
popup.codebox.setValue(text);
|
|
popup.codebox.clearHistory();
|
|
popup.codebox.markClean();
|
|
}
|
|
// overwrite default extraKeys as those are inapplicable in popup context
|
|
popup.codebox.options.extraKeys = {
|
|
'Ctrl-Enter': doImport,
|
|
'Shift-Ctrl-Enter': () => doImport({replaceOldStyle: true}),
|
|
};
|
|
|
|
function doImport({replaceOldStyle = false}) {
|
|
lockPageUI(true);
|
|
API.parseCss({code: popup.codebox.getValue().trim()})
|
|
.then(({sections, errors}) => {
|
|
// shouldn't happen but just in case
|
|
if (!sections.length || errors.length) {
|
|
throw errors;
|
|
}
|
|
if (replaceOldStyle) {
|
|
return replaceSections(sections);
|
|
}
|
|
return new Promise(resolve => initSection({sections, done: resolve, focusOn: false}));
|
|
})
|
|
.then(() => {
|
|
$('.dismiss').dispatchEvent(new Event('click'));
|
|
})
|
|
.catch(showError)
|
|
.then(() => lockPageUI(false));
|
|
}
|
|
|
|
function lockPageUI(locked) {
|
|
document.documentElement.style.pointerEvents = locked ? 'none' : '';
|
|
if (popup.codebox) {
|
|
popup.classList.toggle('ready', locked ? false : !popup.codebox.isBlank());
|
|
popup.codebox.options.readOnly = locked;
|
|
popup.codebox.display.wrapper.style.opacity = locked ? '.5' : '';
|
|
}
|
|
}
|
|
|
|
function showError(errors) {
|
|
messageBox({
|
|
className: 'center danger',
|
|
title: t('styleFromMozillaFormatError'),
|
|
contents: $create('pre', Array.isArray(errors) ? errors.join('\n') : errors),
|
|
buttons: [t('confirmClose')],
|
|
});
|
|
}
|
|
}
|
|
|
|
function updateSectionOrder() {
|
|
const oldOrder = sectionOrder;
|
|
const validSections = sections.filter(s => !s.isRemoved());
|
|
sectionOrder = validSections.map(s => s.id).join(',');
|
|
dirty.modify('sectionOrder', oldOrder, sectionOrder);
|
|
container.dataset.sectionCount = validSections.length;
|
|
linter.refreshReport();
|
|
}
|
|
|
|
function getModel() {
|
|
return Object.assign({}, style, {
|
|
sections: sections.filter(s => !s.isRemoved()).map(s => s.getModel())
|
|
});
|
|
}
|
|
|
|
function validate() {
|
|
if (!nameEl.reportValidity()) {
|
|
messageBox.alert(t('styleMissingName'));
|
|
return false;
|
|
}
|
|
for (const section of sections) {
|
|
for (const apply of section.appliesTo) {
|
|
if (apply.getType() !== 'regexp') {
|
|
continue;
|
|
}
|
|
if (!apply.valueEl.reportValidity()) {
|
|
messageBox.alert(t('styleBadRegexp'));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function saveStyle() {
|
|
if (!dirty.isDirty()) {
|
|
return;
|
|
}
|
|
const newStyle = getModel();
|
|
if (!validate(newStyle)) {
|
|
return;
|
|
}
|
|
API.editSave(newStyle)
|
|
.then(newStyle => {
|
|
sessionStorage.justEditedStyleId = newStyle.id;
|
|
replaceStyle(newStyle);
|
|
});
|
|
}
|
|
|
|
function updateHeader() {
|
|
nameEl.value = style.name || '';
|
|
enabledEl.checked = style.enabled !== false;
|
|
$('#url').href = style.url || '';
|
|
updateTitle();
|
|
}
|
|
|
|
function updateLivePreview() {
|
|
debounce(_updateLivePreview, 200);
|
|
}
|
|
|
|
function _updateLivePreview() {
|
|
livePreview.update(getModel());
|
|
}
|
|
|
|
function updateTitle() {
|
|
const name = style.name;
|
|
const clean = !dirty.isDirty();
|
|
const title = !style.id ? t('addStyleTitle') : name;
|
|
document.title = (clean ? '' : '* ') + title;
|
|
$('#save-button').disabled = clean;
|
|
}
|
|
|
|
function initSection({
|
|
sections: originalSections,
|
|
total = originalSections.length,
|
|
focusOn = 0,
|
|
done
|
|
}) {
|
|
let renderIndex = sections.length;
|
|
container.classList.add('hidden');
|
|
chunk();
|
|
|
|
function chunk() {
|
|
if (!originalSections.length) {
|
|
setGlobalProgress();
|
|
if (focusOn !== false) {
|
|
sections[focusOn].cm.focus();
|
|
}
|
|
container.classList.remove('hidden');
|
|
for (; renderIndex < sections.length; renderIndex++) {
|
|
sections[renderIndex].cm.refreshOnView();
|
|
}
|
|
if (done) {
|
|
done();
|
|
}
|
|
return;
|
|
}
|
|
const t0 = performance.now();
|
|
while (originalSections.length && performance.now() - t0 < 100) {
|
|
insertSectionAfter(originalSections.shift());
|
|
}
|
|
setGlobalProgress(total - originalSections.length, total);
|
|
setTimeout(chunk);
|
|
}
|
|
}
|
|
|
|
function removeSection(section) {
|
|
if (sections.every(s => s.isRemoved() || s === section)) {
|
|
throw new Error('Cannot remove last section');
|
|
}
|
|
if (!section.getCode()) {
|
|
const index = sections.indexOf(section);
|
|
sections.splice(index, 1);
|
|
section.el.remove();
|
|
section.remove(true);
|
|
} else {
|
|
const lines = [];
|
|
const MAX_LINES = 10;
|
|
section.cm.doc.iter(0, MAX_LINES + 1, ({text}) => lines.push(text) && false);
|
|
const title = t('sectionCode') + '\n' +
|
|
'-'.repeat(20) + '\n' +
|
|
lines.slice(0, MAX_LINES).map(s => clipString(s, 100)).join('\n') +
|
|
(lines.length > MAX_LINES ? '\n...' : '');
|
|
$('.deleted-section', section.el).title = title;
|
|
section.remove(false);
|
|
}
|
|
dirty.remove(section, section);
|
|
updateSectionOrder();
|
|
section.off(updateLivePreview);
|
|
updateLivePreview();
|
|
}
|
|
|
|
function restoreSection(section) {
|
|
section.restore();
|
|
updateSectionOrder();
|
|
section.onChange(updateLivePreview);
|
|
updateLivePreview();
|
|
}
|
|
|
|
function insertSectionAfter(init, base) {
|
|
if (!init) {
|
|
init = {code: '', urlPrefixes: ['http://example.com']};
|
|
}
|
|
const section = createSection(init);
|
|
if (base) {
|
|
const index = sections.indexOf(base);
|
|
sections.splice(index + 1, 0, section);
|
|
container.insertBefore(section.el, base.el.nextSibling);
|
|
} else {
|
|
sections.push(section);
|
|
container.appendChild(section.el);
|
|
}
|
|
section.render();
|
|
// maximizeCodeHeight(section.el);
|
|
updateSectionOrder();
|
|
section.onChange(updateLivePreview);
|
|
updateLivePreview();
|
|
}
|
|
|
|
function moveSectionUp(section) {
|
|
const index = sections.indexOf(section);
|
|
if (index === 0) {
|
|
return;
|
|
}
|
|
container.insertBefore(section.el, sections[index - 1].el);
|
|
sections[index] = sections[index - 1];
|
|
sections[index - 1] = section;
|
|
updateSectionOrder();
|
|
}
|
|
|
|
function moveSectionDown(section) {
|
|
const index = sections.indexOf(section);
|
|
if (index === sections.length - 1) {
|
|
return;
|
|
}
|
|
container.insertBefore(sections[index + 1].el, section.el);
|
|
sections[index] = sections[index + 1];
|
|
sections[index + 1] = section;
|
|
updateSectionOrder();
|
|
}
|
|
|
|
function createSection(originalSection) {
|
|
const sectionId = INC_ID++;
|
|
const el = template.section.cloneNode(true);
|
|
const cm = cmFactory.create(wrapper => {
|
|
el.insertBefore(wrapper, $('.code-label', el).nextSibling);
|
|
}, {value: originalSection.code});
|
|
|
|
const changeListeners = new Set();
|
|
|
|
const appliesToContainer = $('.applies-to-list', el);
|
|
const appliesTo = [];
|
|
for (const [key, fnName] of Object.entries(propertyToCss)) {
|
|
if (originalSection[key]) {
|
|
originalSection[key].forEach(value =>
|
|
insertApplyAfter({type: fnName, value})
|
|
);
|
|
}
|
|
}
|
|
if (!appliesTo.length) {
|
|
insertApplyAfter({all: true});
|
|
}
|
|
|
|
let changeGeneration = cm.changeGeneration();
|
|
let removed = false;
|
|
|
|
registerEvents();
|
|
updateRegexpTester();
|
|
createResizeGrip(cm);
|
|
|
|
linter.enableForEditor(cm);
|
|
|
|
let lastActive = 0;
|
|
|
|
const section = {
|
|
id: sectionId,
|
|
el,
|
|
cm,
|
|
render,
|
|
getCode,
|
|
getModel,
|
|
remove,
|
|
restore,
|
|
isRemoved: () => removed,
|
|
onChange,
|
|
off,
|
|
getLastActive: () => lastActive,
|
|
appliesTo
|
|
};
|
|
return section;
|
|
|
|
function onChange(fn) {
|
|
changeListeners.add(fn);
|
|
}
|
|
|
|
function off(fn) {
|
|
changeListeners.delete(fn);
|
|
}
|
|
|
|
function emitSectionChange() {
|
|
for (const fn of changeListeners) {
|
|
fn();
|
|
}
|
|
}
|
|
|
|
function getModel() {
|
|
const section = {
|
|
code: cm.getValue()
|
|
};
|
|
for (const apply of appliesTo) {
|
|
if (apply.all) {
|
|
continue;
|
|
}
|
|
const key = CssToProperty[apply.getType()];
|
|
if (!section[key]) {
|
|
section[key] = [];
|
|
}
|
|
section[key].push(apply.getValue());
|
|
}
|
|
return section;
|
|
}
|
|
|
|
function registerEvents() {
|
|
cm.on('changes', () => {
|
|
const newGeneration = cm.changeGeneration();
|
|
dirty.modify(`section.${sectionId}.code`, changeGeneration, newGeneration);
|
|
changeGeneration = newGeneration;
|
|
emitSectionChange();
|
|
});
|
|
cm.on('paste', (cm, event) => {
|
|
const text = event.clipboardData.getData('text') || '';
|
|
if (
|
|
text.includes('@-moz-document') &&
|
|
text.replace(/\/\*[\s\S]*?(?:\*\/|$)/g, '')
|
|
.match(/@-moz-document[\s\r\n]+(url|url-prefix|domain|regexp)\(/)
|
|
) {
|
|
event.preventDefault();
|
|
fromMozillaFormat(text);
|
|
}
|
|
// FIXME: why?
|
|
// if (editors.length === 1) {
|
|
// setTimeout(() => {
|
|
// if (cm.display.sizer.clientHeight > cm.display.wrapper.clientHeight) {
|
|
// maximizeCodeHeight.stats = null;
|
|
// maximizeCodeHeight(cm.getSection(), true);
|
|
// }
|
|
// });
|
|
// }
|
|
});
|
|
if (!FIREFOX) {
|
|
cm.on('mousedown', (cm, event) => toggleContextMenuDelete.call(cm, event));
|
|
}
|
|
cm.on('focus', () => {
|
|
lastActive = Date.now();
|
|
});
|
|
|
|
cm.display.wrapper.addEventListener('keydown', event =>
|
|
nextPrevEditorOnKeydown(cm, event), true);
|
|
|
|
$('.applies-to-help', el).addEventListener('click', showAppliesToHelp);
|
|
$('.remove-section', el).addEventListener('click', () => removeSection(section));
|
|
$('.add-section', el).addEventListener('click', () => insertSectionAfter(undefined, section));
|
|
$('.clone-section', el).addEventListener('click', () => insertSectionAfter(getModel(), section));
|
|
$('.move-section-up', el).addEventListener('click', () => moveSectionUp(section));
|
|
$('.move-section-down', el).addEventListener('click', () => moveSectionDown(section));
|
|
$('.beautify-section', el).addEventListener('click', () => beautify([cm]));
|
|
$('.restore-section', el).addEventListener('click', () => restoreSection(section));
|
|
$('.test-regexp', el).addEventListener('click', () => {
|
|
regExpTester.toggle();
|
|
updateRegexpTester();
|
|
});
|
|
}
|
|
|
|
function getCode() {
|
|
return cm.getValue();
|
|
}
|
|
|
|
function remove(destroy = false) {
|
|
linter.disableForEditor(cm);
|
|
el.classList.add('removed');
|
|
removed = true;
|
|
appliesTo.forEach(a => a.remove());
|
|
if (destroy) {
|
|
cmFactory.destroy(cm);
|
|
}
|
|
}
|
|
|
|
function restore() {
|
|
linter.enableForEditor(cm);
|
|
el.classList.remove('removed');
|
|
removed = false;
|
|
appliesTo.forEach(a => a.restore());
|
|
render();
|
|
}
|
|
|
|
function render() {
|
|
cm.refresh();
|
|
}
|
|
|
|
function updateRegexpTester() {
|
|
const regexps = appliesTo.filter(a => a.getType() === 'regexp')
|
|
.map(a => a.getValue());
|
|
if (regexps.length) {
|
|
el.classList.add('has-regexp');
|
|
regExpTester.update(regexps);
|
|
} else {
|
|
el.classList.remove('has-regexp');
|
|
regExpTester.toggle(false);
|
|
}
|
|
}
|
|
|
|
function insertApplyAfter(init, base) {
|
|
const apply = createApply(init);
|
|
if (base) {
|
|
const index = appliesTo.indexOf(base);
|
|
appliesTo.splice(index + 1, 0, apply);
|
|
appliesToContainer.insertBefore(apply.el, base.el.nextSibling);
|
|
} else {
|
|
appliesTo.push(apply);
|
|
appliesToContainer.appendChild(apply.el);
|
|
}
|
|
dirty.add(apply, apply);
|
|
if (appliesTo.length > 1 && appliesTo[0].all) {
|
|
removeApply(appliesTo[0]);
|
|
}
|
|
emitSectionChange();
|
|
}
|
|
|
|
function removeApply(apply) {
|
|
const index = appliesTo.indexOf(apply);
|
|
appliesTo.splice(index, 1);
|
|
apply.remove();
|
|
apply.el.remove();
|
|
dirty.remove(apply, apply);
|
|
if (!appliesTo.length) {
|
|
insertApplyAfter({all: true});
|
|
}
|
|
emitSectionChange();
|
|
}
|
|
|
|
function createApply({type = 'url', value, all = false}) {
|
|
const applyId = INC_ID++;
|
|
const dirtyPrefix = `section.${sectionId}.apply.${applyId}`;
|
|
const el = all ? template.appliesToEverything.cloneNode(true) :
|
|
template.appliesTo.cloneNode(true);
|
|
|
|
const selectEl = !all && $('.applies-type', el);
|
|
if (selectEl) {
|
|
selectEl.value = type;
|
|
selectEl.addEventListener('change', () => {
|
|
const oldKey = type;
|
|
dirty.modify(`${dirtyPrefix}.type`, type, selectEl.value);
|
|
type = selectEl.value;
|
|
if (oldKey === 'regexp' || type === 'regexp') {
|
|
updateRegexpTester();
|
|
}
|
|
emitSectionChange();
|
|
validate();
|
|
});
|
|
}
|
|
|
|
const valueEl = !all && $('.applies-value', el);
|
|
if (valueEl) {
|
|
valueEl.value = value;
|
|
valueEl.addEventListener('input', () => {
|
|
dirty.modify(`${dirtyPrefix}.value`, value, valueEl.value);
|
|
value = valueEl.value;
|
|
if (type === 'regexp') {
|
|
updateRegexpTester();
|
|
}
|
|
emitSectionChange();
|
|
});
|
|
valueEl.addEventListener('change', validate);
|
|
}
|
|
|
|
const apply = {
|
|
id: applyId,
|
|
all,
|
|
remove,
|
|
restore,
|
|
el,
|
|
getType: () => type,
|
|
getValue: () => value,
|
|
valueEl
|
|
};
|
|
|
|
const removeButton = $('.remove-applies-to', el);
|
|
if (removeButton) {
|
|
removeButton.addEventListener('click', e => {
|
|
e.preventDefault();
|
|
removeApply(apply);
|
|
});
|
|
}
|
|
$('.add-applies-to', el).addEventListener('click', e => {
|
|
e.preventDefault();
|
|
insertApplyAfter({type, value: ''}, apply);
|
|
});
|
|
|
|
return apply;
|
|
|
|
function validate() {
|
|
if (type !== 'regexp' || tryRegExp(value)) {
|
|
valueEl.setCustomValidity('');
|
|
} else {
|
|
valueEl.setCustomValidity(t('styleBadRegexp'));
|
|
setTimeout(() => valueEl.reportValidity());
|
|
}
|
|
}
|
|
|
|
function remove() {
|
|
dirty.remove(`${dirtyPrefix}.type`, type);
|
|
dirty.remove(`${dirtyPrefix}.value`, value);
|
|
}
|
|
|
|
function restore() {
|
|
dirty.add(`${dirtyPrefix}.type`, type);
|
|
dirty.add(`${dirtyPrefix}.value`, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
function replaceSections(originalSections) {
|
|
for (const section of sections) {
|
|
section.remove(true);
|
|
}
|
|
sections.length = 0;
|
|
container.textContent = '';
|
|
return new Promise(resolve => initSection({sections: originalSections, done: resolve}));
|
|
}
|
|
|
|
function replaceStyle(newStyle, codeIsUpdated) {
|
|
// FIXME: avoid recreating all editors?
|
|
reinit().then(() => {
|
|
style = newStyle;
|
|
updateHeader();
|
|
dirty.clear();
|
|
// Go from new style URL to edit style URL
|
|
if (location.href.indexOf('id=') === -1 && style.id) {
|
|
history.replaceState({}, document.title, 'edit.html?id=' + style.id);
|
|
$('#heading').textContent = t('editStyleHeading');
|
|
}
|
|
livePreview.show(Boolean(style.id));
|
|
});
|
|
|
|
function reinit() {
|
|
if (codeIsUpdated !== false) {
|
|
return replaceSections(newStyle.sections.slice());
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
}
|