mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor
synced 2024-12-02 01:46:47 +00:00
e655880d14
Don't enable valid-jsdoc yet though, due to @chainable bug. Change-Id: I4d2a6de19c72c6e4c20733446616d8046419d431
432 lines
12 KiB
JavaScript
432 lines
12 KiB
JavaScript
/*!
|
|
* VisualEditor MediaWiki Initialization DesktopWikitextArticleTarget class.
|
|
*
|
|
* @copyright 2011-2015 VisualEditor Team and others; see AUTHORS.txt
|
|
* @license The MIT License (MIT); see LICENSE.txt
|
|
*/
|
|
|
|
/**
|
|
*
|
|
* @class
|
|
* @extends ve.init.mw.DesktopArticleTarget
|
|
*
|
|
* @constructor
|
|
* @param {Object} [config] Configuration options
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget = function VeInitMwDesktopWikitextArticleTarget( config ) {
|
|
// Parent constructor
|
|
ve.init.mw.DesktopWikitextArticleTarget.super.call( this, config );
|
|
};
|
|
|
|
/* Inheritance */
|
|
|
|
OO.inheritClass( ve.init.mw.DesktopWikitextArticleTarget, ve.init.mw.DesktopArticleTarget );
|
|
|
|
/* Events */
|
|
|
|
/* Static Properties */
|
|
|
|
ve.init.mw.DesktopWikitextArticleTarget.static.trackingName = 'desktopWikitext';
|
|
|
|
ve.init.mw.DesktopWikitextArticleTarget.static.importRules = ve.extendObject( {},
|
|
ve.init.mw.DesktopWikitextArticleTarget.static.importRules, {
|
|
all: {
|
|
keepEmptyContentBranches: true
|
|
}
|
|
}
|
|
);
|
|
|
|
/* Methods */
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.switchToWikitextEditor = function ( discardChanges, modified ) {
|
|
var dataPromise,
|
|
target = this;
|
|
|
|
if ( discardChanges ) {
|
|
dataPromise = mw.libs.ve.targetLoader.requestPageData(
|
|
'source',
|
|
this.pageName,
|
|
null, // We may have this.section but VE is always full page at the moment
|
|
this.requestedRevId,
|
|
this.constructor.name
|
|
).then(
|
|
function ( response ) { return response; },
|
|
function () {
|
|
// TODO: Some sort of progress bar?
|
|
ve.init.mw.DesktopWikitextArticleTarget.super.prototype.switchToWikitextEditor.call(
|
|
target,
|
|
discardChanges,
|
|
modified
|
|
);
|
|
// Keep everything else waiting so our error handler can do its business
|
|
return $.Deferred().promise();
|
|
}
|
|
);
|
|
} else {
|
|
this.serialize( this.getDocToSave() );
|
|
dataPromise = this.serializing.then( function ( response ) {
|
|
// HACK - add parameters the API doesn't provide for a VE->WT switch
|
|
var data = response.visualeditoredit;
|
|
data.etag = target.etag;
|
|
data.fromEditedState = modified;
|
|
data.notices = target.remoteNotices;
|
|
data.protectedClasses = target.protectedClasses;
|
|
data.basetimestamp = target.baseTimeStamp;
|
|
data.starttimestamp = target.startTimeStamp;
|
|
data.oldid = target.revid;
|
|
return response;
|
|
} );
|
|
}
|
|
this.setMode( 'source' );
|
|
this.reloadSurface( dataPromise );
|
|
};
|
|
|
|
/**
|
|
* Switch to the visual editor.
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.switchToVisualEditor = function () {
|
|
var dataPromise, windowManager, switchWindow,
|
|
target = this;
|
|
|
|
if ( this.section !== null ) {
|
|
// WT -> VE switching is not yet supported in sections, so
|
|
// show a discard-only confirm dialog, then reload the whole page.
|
|
windowManager = new OO.ui.WindowManager();
|
|
switchWindow = new mw.libs.ve.SwitchConfirmDialog();
|
|
$( 'body' ).append( windowManager.$element );
|
|
windowManager.addWindows( [ switchWindow ] );
|
|
windowManager.openWindow( switchWindow, { mode: 'simple' } )
|
|
.then( function ( opened ) {
|
|
return opened;
|
|
} )
|
|
.then( function ( closing ) { return closing; } )
|
|
.then( function ( data ) {
|
|
if ( data && data.action === 'discard' ) {
|
|
target.setMode( 'visual' );
|
|
target.reloadSurface();
|
|
}
|
|
windowManager.destroy();
|
|
} );
|
|
} else {
|
|
dataPromise = mw.libs.ve.targetLoader.requestParsoidData(
|
|
this.pageName,
|
|
this.revid,
|
|
this.constructor.name,
|
|
this.edited,
|
|
this.getDocToSave()
|
|
);
|
|
|
|
this.setMode( 'visual' );
|
|
this.reloadSurface( dataPromise );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.editSource = function () {
|
|
// Don't bother with a confirm dialog when switching to the new wikitext editor.
|
|
// Second argument (modified) is never checked if we are keeping changes, so
|
|
// don't bother computing it.
|
|
this.switchToWikitextEditor( false );
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.onWindowPopState = function ( e ) {
|
|
var veaction;
|
|
|
|
if ( !this.verifyPopState( e.state ) ) {
|
|
return;
|
|
}
|
|
|
|
// Parent method
|
|
ve.init.mw.DesktopWikitextArticleTarget.super.prototype.onWindowPopState.apply( this, arguments );
|
|
|
|
veaction = this.currentUri.query.veaction;
|
|
|
|
if ( this.active ) {
|
|
if ( veaction === 'editsource' && this.mode === 'visual' ) {
|
|
this.actFromPopState = true;
|
|
this.switchToWikitextEditor();
|
|
} else if ( veaction === 'edit' && this.mode === 'source' ) {
|
|
this.actFromPopState = true;
|
|
this.switchToVisualEditor();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Reload the target surface in the new editor mode
|
|
*
|
|
* @param {jQuery.Promise} [dataPromise] Data promise, if any
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.reloadSurface = function ( dataPromise ) {
|
|
var target = this;
|
|
// Create progress - will be discarded when surface is destroyed.
|
|
this.getSurface().createProgress(
|
|
$.Deferred().promise(),
|
|
ve.msg( this.mode === 'source' ? 'visualeditor-mweditmodesource-progress' : 'visualeditor-mweditmodeve-progress' ),
|
|
true /* non-cancellable */
|
|
);
|
|
this.activating = true;
|
|
this.activatingDeferred = $.Deferred();
|
|
this.load( dataPromise );
|
|
this.activatingDeferred.done( function () {
|
|
target.updateHistoryState();
|
|
target.afterActivate();
|
|
target.setupTriggerListeners();
|
|
} );
|
|
this.toolbarSetupDeferred.resolve();
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.setupToolbar = function ( surface ) {
|
|
var actionGroups;
|
|
|
|
// Parent method
|
|
ve.init.mw.DesktopWikitextArticleTarget.super.prototype.setupToolbar.apply( this, arguments );
|
|
|
|
if ( this.mode === 'source' ) {
|
|
// HACK: Replace source button with VE button. This should be via the registry,
|
|
// or we should have a toggle tool.
|
|
actionGroups = ve.copy( this.constructor.static.actionGroups );
|
|
actionGroups[ 2 ].include[ 0 ] = 'editModeVisual';
|
|
this.getActions().setup( actionGroups, surface );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.parseHtml = function ( content ) {
|
|
var doc;
|
|
if ( this.mode === 'source' ) {
|
|
doc = ve.createDocumentFromHtml( '' );
|
|
|
|
content.split( '\n' ).forEach( function ( line ) {
|
|
var p = doc.createElement( 'p' );
|
|
p.appendChild( doc.createTextNode( line ) );
|
|
doc.body.appendChild( p );
|
|
} );
|
|
|
|
return doc;
|
|
} else {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.parseHtml.apply( this, arguments );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.createTargetWidget = function ( dmDoc, config ) {
|
|
if ( this.mode === 'source' ) {
|
|
return new ve.ui.MWTargetWidget( dmDoc, ve.extendObject( {
|
|
commandRegistry: ve.ui.commandRegistry,
|
|
sequenceRegistry: ve.ui.sequenceRegistry,
|
|
dataTransferHandlerFactory: ve.ui.dataTransferHandlerFactory
|
|
}, config ) );
|
|
} else {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.createTargetWidget.apply( this, arguments );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.createSurface = function ( dmDoc, config ) {
|
|
// Use a regular surface in target widgets
|
|
if ( this.mode !== 'source' || ( config && config.inTargetWidget ) ) {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.createSurface.apply( this, arguments );
|
|
} else {
|
|
return new ve.ui.MWDesktopWikitextSurface( dmDoc, this.getSurfaceConfig( {
|
|
commandRegistry: ve.ui.wikitextCommandRegistry,
|
|
sequenceRegistry: ve.ui.wikitextSequenceRegistry,
|
|
dataTransferHandlerFactory: ve.ui.wikitextDataTransferHandlerFactory
|
|
} ) );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.restoreEditSection = function () {
|
|
if ( this.mode !== 'source' ) {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.restoreEditSection.apply( this, arguments );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get a wikitext fragment from a document
|
|
*
|
|
* @param {ve.dm.Document} doc Document
|
|
* @param {boolean} [useRevision=true] Whether to use the revision ID + ETag
|
|
* @return {jQuery.Promise} Abortable promise which resolves with a wikitext string
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.getWikitextFragment = function ( doc, useRevision ) {
|
|
var promise, xhr,
|
|
params = {
|
|
action: 'visualeditoredit',
|
|
token: this.editToken,
|
|
paction: 'serialize',
|
|
html: ve.dm.converter.getDomFromModel( doc ).body.innerHTML,
|
|
page: this.pageName
|
|
};
|
|
|
|
if ( useRevision === undefined || useRevision ) {
|
|
params.oldid = this.revid;
|
|
params.etag = this.etag;
|
|
}
|
|
|
|
xhr = new mw.Api().post(
|
|
params,
|
|
{ contentType: 'multipart/form-data' }
|
|
);
|
|
|
|
promise = xhr.then( function ( response ) {
|
|
if ( response.visualeditoredit ) {
|
|
return response.visualeditoredit.content;
|
|
}
|
|
return $.Deferred().reject();
|
|
} );
|
|
|
|
promise.abort = function () {
|
|
xhr.abort();
|
|
};
|
|
|
|
return promise;
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.createModelFromDom = function ( doc ) {
|
|
var i, l, conf, children, data;
|
|
|
|
if ( this.mode !== 'source' ) {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.createModelFromDom.apply( this, arguments );
|
|
}
|
|
|
|
conf = mw.config.get( 'wgVisualEditor' );
|
|
children = doc.body.children;
|
|
data = [];
|
|
|
|
// Wikitext documents are just plain text paragraphs, so we can just do a simple manual conversion.
|
|
for ( i = 0, l = children.length; i < l; i++ ) {
|
|
data.push( { type: 'paragraph' } );
|
|
ve.batchPush( data, children[ i ].textContent.split( '' ) );
|
|
data.push( { type: '/paragraph' } );
|
|
}
|
|
data.push( { type: 'internalList' }, { type: '/internalList' } );
|
|
return new ve.dm.Document( data, doc, null, null, null, conf.pageLanguageCode, conf.pageLanguageDir );
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.prepareCacheKey = function () {
|
|
if ( this.mode !== 'source' ) {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.prepareCacheKey.apply( this, arguments );
|
|
}
|
|
// else: No need, just wikitext
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.createDocToSave = function () {
|
|
var i, l, text, data;
|
|
|
|
if ( this.mode !== 'source' ) {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.createDocToSave.apply( this, arguments );
|
|
}
|
|
|
|
text = '';
|
|
data = this.getSurface().getModel().getDocument().data.data;
|
|
for ( i = 0, l = data.length; i < l; i++ ) {
|
|
if ( data[ i ].type === '/paragraph' && data[ i + 1 ].type === 'paragraph' ) {
|
|
text += '\n';
|
|
} else if ( !data[ i ].type ) {
|
|
text += data[ i ];
|
|
}
|
|
}
|
|
|
|
return text;
|
|
};
|
|
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.init.mw.DesktopWikitextArticleTarget.prototype.tryWithPreparedCacheKey = function ( doc, options ) {
|
|
var data, postData;
|
|
if ( this.mode === 'source' ) {
|
|
data = {
|
|
wikitext: doc,
|
|
format: 'json'
|
|
};
|
|
if ( this.section !== null ) {
|
|
data.section = this.section;
|
|
}
|
|
postData = ve.extendObject( {}, options, data );
|
|
if ( data.token ) {
|
|
return new mw.Api().post( postData, { contentType: 'multipart/form-data' } );
|
|
}
|
|
return new mw.Api().postWithToken( 'csrf', postData, { contentType: 'multipart/form-data' } );
|
|
} else {
|
|
// Parent method
|
|
return ve.init.mw.DesktopWikitextArticleTarget.super.prototype.tryWithPreparedCacheKey.apply( this, arguments );
|
|
}
|
|
};
|
|
|
|
/* Registration */
|
|
|
|
ve.init.mw.targetFactory.register( ve.init.mw.DesktopWikitextArticleTarget );
|
|
|
|
/**
|
|
* MediaWiki UserInterface edit mode visual tool.
|
|
*
|
|
* @class
|
|
* @extends ve.ui.MWEditModeTool
|
|
* @constructor
|
|
* @param {OO.ui.ToolGroup} toolGroup
|
|
* @param {Object} [config] Config options
|
|
*/
|
|
ve.ui.MWEditModeVisualTool = function VeUiMWEditModeVisualTool() {
|
|
ve.ui.MWEditModeVisualTool.super.apply( this, arguments );
|
|
};
|
|
OO.inheritClass( ve.ui.MWEditModeVisualTool, ve.ui.MWEditModeTool );
|
|
ve.ui.MWEditModeVisualTool.static.name = 'editModeVisual';
|
|
ve.ui.MWEditModeVisualTool.static.icon = 'edit';
|
|
ve.ui.MWEditModeVisualTool.static.title =
|
|
OO.ui.deferMsg( 'visualeditor-mweditmodeve-tool' );
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.ui.MWEditModeVisualTool.prototype.onSelect = function () {
|
|
this.toolbar.getTarget().switchToVisualEditor();
|
|
this.setActive( false );
|
|
};
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
ve.ui.MWEditModeVisualTool.prototype.onUpdateState = function () {
|
|
// Parent method
|
|
ve.ui.MWEditModeVisualTool.super.prototype.onUpdateState.apply( this, arguments );
|
|
|
|
this.setDisabled( ve.init.target.modes.indexOf( 'visual' ) === -1 );
|
|
};
|
|
ve.ui.toolFactory.register( ve.ui.MWEditModeVisualTool );
|