Файловый менеджер - Редактировать - /var/www/html/mediawiki-1.43.1/extensions/TemplateData/modules/ext.templateDataGenerator.data/Model.js
Ðазад
/** * TemplateData Model * * @class * @mixes OO.EventEmitter * * @constructor */ function Model() { // Mixin constructors OO.EventEmitter.call( this ); // Properties this.description = {}; this.maps = undefined; this.mapsChanged = false; this.originalMaps = undefined; this.format = null; this.params = {}; this.paramIdentifierCounter = 2; this.sourceCodeParameters = []; this.paramOrder = []; this.paramOrderChanged = false; this.originalTemplateDataObject = null; } /* Inheritance */ OO.mixinClass( Model, OO.EventEmitter ); /* Events */ /** * @event add-param * @param {string} key Parameter key * @param {Object} data Parameter data */ /** * @event change-description * @param {string} description New template description * @param {Object} [language] Description language, if supplied */ /** * @event change-paramOrder * @param {string[]} orderArray Parameter key array in order */ /** * @event change-property * @param {string} paramKey Parameter key * @param {string} prop Property name * @param {Mixed} value * @param {string} language */ /** * @event change */ /* Static Methods */ /** * Compare two objects or strings * * @param {Object|string} obj1 Base object * @param {Object|string} obj2 Compared object * @param {boolean} [allowSubset] Allow the second object to be a * partial object (or a subset) of the first. * @return {boolean} Objects have equal values */ Model.static.compare = function ( obj1, obj2, allowSubset ) { if ( obj1 === obj2 || ( allowSubset && obj2 === undefined ) ) { return true; } if ( typeof obj1 !== typeof obj2 ) { return false; } return typeof obj1 === 'object' && OO.compare( obj2, obj1, allowSubset ); }; /** * Translate obsolete parameter types into the new types * * @param {string} paramType Given type * @return {string} Normalized non-obsolete type */ Model.static.translateObsoleteParamTypes = function ( paramType ) { return paramType.replace( /^string\//, '' ); }; /** * Retrieve information about all legal properties for a parameter. * * @param {boolean} getFullData Retrieve full information about each * parameter. If false, the method will return an array of property * names only. * @return {Object|string[]} Legal property names with or without their * definition data */ Model.static.getAllProperties = function ( getFullData ) { const properties = { name: { type: 'string', // Validation regex restrict: /[|=]|}}/ }, aliases: { type: 'array' }, label: { type: 'string', allowLanguages: true }, description: { type: 'string', allowLanguages: true }, example: { type: 'string', allowLanguages: true }, type: { type: 'select', children: [ 'unknown', 'boolean', 'content', 'wiki-file-name', 'line', 'number', 'date', 'wiki-page-name', 'string', 'wiki-template-name', 'unbalanced-wikitext', 'url', 'wiki-user-name' ], default: 'unknown' }, suggestedvalues: { type: 'array' }, default: { type: 'string', multiline: true, allowLanguages: true }, autovalue: { type: 'string' }, status: { type: 'select', children: [ 'optional', 'deprecated', 'required', 'suggested' ], default: 'optional' }, deprecated: { type: 'boolean', // This should only be defined for boolean properties. // Define the property that represents the text value. textValue: 'deprecatedValue' }, deprecatedValue: { type: 'string' }, required: { type: 'boolean' }, suggested: { type: 'boolean' } }; if ( !getFullData ) { return Object.keys( properties ); } else { return properties; } }; /** * Retrieve the list of property names that allow for multiple languages. * * @return {string[]} Property names */ Model.static.getPropertiesWithLanguage = function () { const result = [], propDefinitions = this.getAllProperties( true ); for ( const prop in propDefinitions ) { if ( propDefinitions[ prop ].allowLanguages ) { result.push( prop ); } } return result; }; /** * Split a string into an array and clean/trim the values * * @param {string} str String to split * @param {string} [delim] Delimeter * @return {string[]} Clean array */ Model.static.splitAndTrimArray = function ( str, delim ) { delim = delim || mw.msg( 'comma-separator' ); const arr = []; str.split( delim ).forEach( ( part ) => { const trimmed = part.trim(); if ( trimmed ) { arr.push( trimmed ); } } ); return arr; }; /** * This is an adjustment of OO.simpleArrayUnion that ignores * empty values when inserting into the unified array. * * @param {...Array} arrays Arrays to union * @return {Array} Union of the arrays */ Model.static.arrayUnionWithoutEmpty = function () { const result = OO.simpleArrayUnion.apply( this, arguments ); // Trim and filter empty strings return result.filter( ( i ) => i.trim() ); }; /** * Create a new mwTemplateData.Model from templatedata object. * * @param {Object|null} tdObject TemplateData parsed object, or null if we are creating a new object. * @param {string[]} paramsInSource Parameter names found in template source * @return {Model} New model */ Model.static.newFromObject = function ( tdObject, paramsInSource ) { const model = new Model(); model.setSourceCodeParameters( paramsInSource || [] ); // Store the original templatedata object for comparison later model.setOriginalTemplateDataObject( tdObject ); tdObject = tdObject || { params: {} }; // Initialize the model model.params = {}; // Add params if ( tdObject.params ) { for ( const param in tdObject.params ) { model.addParam( param, tdObject.params[ param ] ); } } // maps if ( tdObject.maps ) { model.setMapInfo( tdObject.maps ); } model.setTemplateDescription( tdObject.description ); // Override the param order if it exists in the templatedata string if ( tdObject.paramOrder && tdObject.paramOrder.length > 0 ) { model.setTemplateParamOrder( tdObject.paramOrder ); } if ( tdObject.format !== undefined ) { model.setTemplateFormat( tdObject.format ); } return model; }; /* Methods */ /** * Go over the importable parameters and check if they are * included in the parameter model. Return the parameter names * that are not included yet. * * @return {string[]} Parameters that are not yet included in * the model */ Model.prototype.getMissingParams = function () { const allParamNames = this.getAllParamNames(), sourceCodeParameters = this.sourceCodeParameters; return sourceCodeParameters.filter( ( sourceCodeParameter ) => allParamNames.indexOf( sourceCodeParameter ) === -1 ); }; /** * Add imported parameters into the model * * @return {Object} Parameters added. -1 for failure. */ Model.prototype.importSourceCodeParameters = function () { const allParamNames = this.getAllParamNames(), existingArray = [], importedArray = [], skippedArray = []; // Check existing params allParamNames.forEach( ( paramKey ) => { if ( this.sourceCodeParameters.indexOf( paramKey ) !== -1 ) { existingArray.push( paramKey ); } } ); // Add sourceCodeParameters to the model this.sourceCodeParameters.forEach( ( sourceCodeParameter ) => { if ( existingArray.indexOf( sourceCodeParameter ) === -1 ) { this.addParam( sourceCodeParameter ); importedArray.push( sourceCodeParameter ); } else { skippedArray.push( sourceCodeParameter ); } } ); return { imported: importedArray, skipped: skippedArray, existing: existingArray }; }; /** * Retrieve all existing language codes in the current templatedata model * * @return {string[]} Language codes in use */ Model.prototype.getExistingLanguageCodes = function () { let result = []; // Take languages from the template description if ( $.isPlainObject( this.description ) ) { result = Object.keys( this.description ); } const languageProps = this.constructor.static.getPropertiesWithLanguage(); // Go over the parameters for ( const param in this.params ) { // Go over the properties for ( const prop in this.params[ param ] ) { if ( languageProps.indexOf( prop ) !== -1 ) { result = this.constructor.static.arrayUnionWithoutEmpty( result, Object.keys( this.params[ param ][ prop ] ) ); } } } return result; }; /** * Add parameter to the model * * @param {string} name * @param {Object} [paramData] Parameter data * @fires add-param * @fires change */ Model.prototype.addParam = function ( name, paramData ) { const data = $.extend( true, {}, paramData ); const key = this.getNewValidParameterKey( name ); // Initialize this.params[ key ] = { name: name }; // Mark the parameter if it is in the template source if ( this.sourceCodeParameters.indexOf( key ) !== -1 ) { this.params[ key ].inSource = true; } // Translate types if ( data.type !== undefined ) { data.type = this.constructor.static.translateObsoleteParamTypes( data.type ); this.params[ key ].type = data.type; } // Get the deprecated value if ( typeof data.deprecated === 'string' ) { this.params[ key ].deprecatedValue = data.deprecated; } // Go over the rest of the data if ( data ) { const language = this.getDefaultLanguage(); const propertiesWithLanguage = this.constructor.static.getPropertiesWithLanguage(); const allProps = this.constructor.static.getAllProperties( true ); for ( const prop in data ) { let propToSet = prop; if ( // This is to make sure that forwards compatibility is achieved // and the code doesn't die on properties that aren't valid allProps[ prop ] && // Check if property should have its text represented in another internal property // (for example, deprecated and deprecatedValue) allProps[ prop ].textValue ) { // Set the textValue property propToSet = allProps[ prop ].textValue; // Set the boolean value in the current property this.setParamProperty( key, prop, !!data[ prop ], language ); if ( typeof data[ prop ] === 'boolean' ) { // Only set the value of the dependent if the value is a string or // language. Otherwise, if the value is boolean, keep the dependent // empty. continue; } } if ( propertiesWithLanguage.indexOf( propToSet ) !== -1 && $.isPlainObject( data[ prop ] ) ) { // Add all language properties for ( const lang in data[ prop ] ) { this.setParamProperty( key, propToSet, data[ prop ], lang ); } } else { this.setParamProperty( key, propToSet, data[ prop ], language ); } } } // Add to paramOrder this.addKeyTemplateParamOrder( key ); // Trigger the add parameter event this.emit( 'add-param', key, this.params[ key ] ); this.emit( 'change' ); }; /** * Retrieve an array of all used parameter names. Note that parameter * names can be different than their stored keys. * * @return {string[]} Used parameter names */ Model.prototype.getAllParamNames = function () { let result = []; for ( const key in this.params ) { const param = this.params[ key ]; result.push( param.name ); if ( param.aliases ) { result = result.concat( param.aliases ); } } return result; }; /** * Set the template description * * @param {string|Object} desc New template description * @param {string} [language] Description language, if supplied. If not given, * will default to the wiki language. * @fires change-description * @fires change */ Model.prototype.setTemplateDescription = function ( desc, language ) { language = language || this.getDefaultLanguage(); if ( !this.constructor.static.compare( this.description[ language ], desc ) ) { if ( typeof desc === 'object' ) { Object.assign( this.description, desc ); this.emit( 'change-description', desc[ language ], language ); } else { this.description[ language ] = desc; this.emit( 'change-description', desc, language ); } this.emit( 'change' ); } }; /** * Get the template description. * * @param {string} [language] Optional language key * @return {string} */ Model.prototype.getTemplateDescription = function ( language ) { language = language || this.getDefaultLanguage(); return this.description[ language ]; }; /** * @param {Object|undefined} map New template map info * @fires change-map * @fires change */ Model.prototype.setMapInfo = function ( map ) { if ( map !== undefined ) { if ( !this.constructor.static.compare( this.maps, map ) ) { if ( this.mapsChanged === false ) { this.originalMaps = OO.copy( map ); this.mapsChanged = true; } this.maps = map; this.emit( 'change-map', map ); this.emit( 'change' ); } } }; /** * Get the template info. * * @return {Object|undefined} The template map info. */ Model.prototype.getMapInfo = function () { return this.maps; }; /** * Get the template info. * * @return {Object|undefined} The Original template map info. */ Model.prototype.getOriginalMapsInfo = function () { return this.originalMaps; }; /** * Get a specific parameter's localized property * * @param {string} paramKey Parameter key * @param {string} property Property name * @param {string} [language] Optional language key * @return {string} Parameter property in specified language */ Model.prototype.getParamValue = function ( paramKey, property, language ) { language = language || this.getDefaultLanguage(); return OO.getProp( this.params, paramKey, property, language ) || ''; }; /** * Get the current wiki language code. Defaults on 'en'. * * @return {string} Wiki language */ Model.prototype.getDefaultLanguage = function () { return mw.config.get( 'wgContentLanguage' ) || 'en'; }; /** * Set template param order array. * * @param {string[]} [orderArray] Parameter key array in order * @fires change-paramOrder * @fires change */ Model.prototype.setTemplateParamOrder = function ( orderArray ) { orderArray = orderArray || []; // TODO: Make the compare method verify order of array? // Copy the array this.paramOrder = orderArray.slice(); this.emit( 'change-paramOrder', orderArray ); this.emit( 'change' ); }; /** * Set template format. * * @param {string|null} [format=null] Preferred format * @fires change-format * @fires change */ Model.prototype.setTemplateFormat = function ( format ) { format = format || null; if ( this.format !== format ) { this.format = format; this.emit( 'change-format', format ); this.emit( 'change' ); } }; /** * Add a key to the end of the paramOrder * * @param {string} key New key the add into the paramOrder * @fires add-paramOrder * @fires change */ Model.prototype.addKeyTemplateParamOrder = function ( key ) { if ( this.paramOrder.indexOf( key ) === -1 ) { this.paramOrder.push( key ); this.emit( 'add-paramOrder', key ); this.emit( 'change' ); } }; /** * TODO: document * * @param {string} key * @param {number} newIndex * @fires change-paramOrder * @fires change */ Model.prototype.reorderParamOrderKey = function ( key, newIndex ) { const keyIndex = this.paramOrder.indexOf( key ); // Move the parameter, account for left shift if moving forwards this.paramOrder.splice( newIndex - ( newIndex > keyIndex ? 1 : 0 ), 0, this.paramOrder.splice( keyIndex, 1 )[ 0 ] ); this.paramOrderChanged = true; // Emit event this.emit( 'change-paramOrder', this.paramOrder ); this.emit( 'change' ); }; /** * Add a key to the end of the paramOrder * * @param {string} key New key the add into the paramOrder * @fires change-paramOrder * @fires change */ Model.prototype.removeKeyTemplateParamOrder = function ( key ) { const keyPos = this.paramOrder.indexOf( key ); if ( keyPos > -1 ) { this.paramOrder.splice( keyPos, 1 ); this.emit( 'change-paramOrder', this.paramOrder ); this.emit( 'change' ); } }; /** * Retrieve the template paramOrder array * * @return {string[]} orderArray Parameter keys in order */ Model.prototype.getTemplateParamOrder = function () { return this.paramOrder; }; /** * Retrieve the template preferred format * * @return {string|null} Preferred format */ Model.prototype.getTemplateFormat = function () { return this.format; }; /** * Set a specific parameter's property * * @param {string} paramKey Parameter key * @param {string} prop Property name * @param {Mixed} value * @param {string} [language] Value language * @return {boolean} Operation was successful * @fires change-property * @fires change */ Model.prototype.setParamProperty = function ( paramKey, prop, value, language ) { const allProps = this.constructor.static.getAllProperties( true ); let status = false; language = language || this.getDefaultLanguage(); if ( !allProps[ prop ] ) { // The property isn't supported yet return status; } const propertiesWithLanguage = this.constructor.static.getPropertiesWithLanguage(); // Check if the property is split by language code if ( propertiesWithLanguage.indexOf( prop ) !== -1 ) { // Initialize property if necessary if ( !$.isPlainObject( this.params[ paramKey ][ prop ] ) ) { this.params[ paramKey ][ prop ] = {}; } value = $.isPlainObject( value ) ? value[ language ] : value; // Compare with language if ( !this.constructor.static.compare( this.params[ paramKey ][ prop ][ language ], value ) ) { this.params[ paramKey ][ prop ][ language ] = value; this.emit( 'change-property', paramKey, prop, value, language ); this.emit( 'change' ); status = true; } } else { // Compare without language if ( !this.constructor.static.compare( this.params[ paramKey ][ prop ], value ) ) { const oldValue = this.params[ paramKey ][ prop ]; this.params[ paramKey ][ prop ] = value; let newKey = value; if ( prop === 'name' && oldValue !== value ) { // See if the parameters already has something with this new key if ( this.params[ newKey ] && !this.params[ newKey ].deleted ) { // Change the key to be something else newKey = this.getNewValidParameterKey( newKey ); } // Copy param details to new name this.params[ newKey ] = this.params[ paramKey ]; // Delete the old param this.params[ paramKey ] = { deleted: true }; } this.emit( 'change-property', paramKey, prop, value, language ); this.emit( 'change' ); if ( prop === 'name' ) { this.paramOrder[ this.paramOrder.indexOf( paramKey ) ] = newKey; this.paramOrderChanged = true; this.emit( 'change-paramOrder', this.paramOrder ); this.emit( 'change' ); } status = true; } } if ( allProps[ prop ].textValue && value === false ) { // Unset the text value if the boolean it depends on is false status = this.setParamProperty( paramKey, allProps[ prop ].textValue, '', language ); } return status; }; /** * Mark a parameter for deletion. * Don't actually delete the parameter so we can make sure it is removed * from the final output. * * @param {string} paramKey Parameter key * @fires delete-param * @fires change */ Model.prototype.deleteParam = function ( paramKey ) { this.params[ paramKey ].deleted = true; // Remove from paramOrder this.removeKeyTemplateParamOrder( paramKey ); this.emit( 'delete-param', paramKey ); this.emit( 'change' ); }; /** * Delete all data attached to a parameter * * @param {string} paramKey Parameter key */ Model.prototype.emptyParamData = function ( paramKey ) { if ( this.params[ paramKey ] ) { // Delete all data and readd the parameter delete this.params[ paramKey ]; this.addParam( paramKey ); // Mark this parameter as intentionally emptied this.params[ paramKey ].emptied = true; } }; /** * Get a parameter property. * * @param {string} paramKey Parameter key * @param {string} prop Parameter property * @return {Mixed|null} Property value if it exists. Returns null if the * parameter key itself doesn't exist. */ Model.prototype.getParamProperty = function ( paramKey, prop ) { if ( this.params[ paramKey ] ) { return this.params[ paramKey ][ prop ]; } return null; }; /** * Retrieve a specific parameter data * * @param {string} key Parameter key * @return {Object|undefined} Parameter data */ Model.prototype.getParamData = function ( key ) { return this.params[ key ]; }; /** * Return the complete object of all parameters. * * @return {Object} All parameters and their data */ Model.prototype.getParams = function () { return this.params; }; Model.prototype.isParamDeleted = function ( key ) { return this.params[ key ] && this.params[ key ].deleted === true; }; Model.prototype.isParamExists = function ( key ) { return Object.prototype.hasOwnProperty.call( this.params, key ); }; /** * Set the original templatedata object * * @param {Object|null} templatedataObj TemplateData object */ Model.prototype.setOriginalTemplateDataObject = function ( templatedataObj ) { this.originalTemplateDataObject = templatedataObj ? $.extend( true, {}, templatedataObj ) : null; }; /** * Get full page name * * @param {string} pageName Page name */ Model.prototype.setFullPageName = function ( pageName ) { this.fullPageName = pageName; }; /** * Set parent page * * @param {string} parent Parent page */ Model.prototype.setParentPage = function ( parent ) { this.parentPage = parent; }; /** * Get page full name * * @return {string} Page full name */ Model.prototype.getFullPageName = function () { return this.fullPageName; }; /** * Get parent page * * @return {string} Parent page */ Model.prototype.getParentPage = function () { return this.parentPage; }; /** * Get original Parameters/Info from the model and discard any changes */ Model.prototype.restoreOriginalMaps = function () { this.setMapInfo( this.getOriginalMapsInfo() ); }; /** * Get original templatedata object * * @return {Object|null} Templatedata object at the beginning of this editing session, or null * if we're creating a new object. */ Model.prototype.getOriginalTemplateDataObject = function () { return this.originalTemplateDataObject; }; /** * Process the current model and output it * * @return {Object} Templatedata object */ Model.prototype.outputTemplateData = function () { const allProps = this.constructor.static.getAllProperties( true ), original = this.getOriginalTemplateDataObject() || {}; original.params = original.params || {}; const result = $.extend( true, {}, original ), defaultLang = this.getDefaultLanguage(); let normalizedValue; // Template description if ( this.description[ defaultLang ] !== undefined ) { normalizedValue = this.propRemoveUnusedLanguages( this.description ); if ( this.isOutputInLanguageObject( result.description, normalizedValue ) ) { result.description = normalizedValue; } else { // Store only one language as a string result.description = normalizedValue[ defaultLang ]; } } else { // Delete description delete result.description; } // Template maps if ( this.maps === undefined || Object.keys( this.maps ).length === 0 ) { delete result.maps; } else { result.maps = this.maps; } // Param order if ( original.paramOrder || this.paramOrderChanged ) { result.paramOrder = this.paramOrder; } else { delete result.paramOrder; } // Format if ( this.format === null ) { delete result.format; } else { result.format = this.format; } // Attach sets as-is for now // TODO: Work properly with sets if ( original.sets ) { result.sets = original.sets; } // Go over parameters in data for ( const paramKey in this.params ) { const key = paramKey; if ( this.params[ key ].deleted ) { delete result.params[ key ]; continue; } // If the user intentionally empties a parameter, delete it from // the result and treat it as a new parameter if ( this.params[ key ].emptied ) { delete result.params[ key ]; } // Check if name was changed and change the key accordingly const name = this.params[ key ].name; const oldKey = key; // Notice for clarity: // Whether the parameter name was changed or not the following // consistency with object keys will be observed: // * oldKey: original will use oldKey (for comparison to the old value) // * key: this.params will use key (for storing without conflict) // * name: result will use name (for valid output) // Check if param is new if ( !result.params[ name ] ) { // New param. Initialize it result.params[ name ] = {}; } // Go over all properties for ( const prop in allProps ) { if ( prop === 'status' || prop === 'deprecatedValue' || prop === 'name' ) { continue; } switch ( allProps[ prop ].type ) { case 'select': // Only include type if the original included type // or if the current type is not undefined if ( original.params[ key ] && original.params[ key ][ prop ] !== 'unknown' && this.params[ key ][ prop ] === 'unknown' ) { result.params[ name ][ prop ] = undefined; } else { result.params[ name ][ prop ] = this.params[ key ][ prop ]; } break; case 'boolean': if ( !this.params[ key ][ prop ] ) { // Only add a literal false value if there was a false // value before if ( original.params[ oldKey ] && original.params[ oldKey ][ prop ] === false ) { result.params[ name ][ prop ] = false; } else { // Otherwise, delete this value delete result.params[ name ][ prop ]; } } else { if ( prop === 'deprecated' ) { result.params[ name ][ prop ] = this.params[ key ].deprecatedValue || true; // Remove deprecatedValue delete result.params[ name ].deprecatedValue; } else { result.params[ name ][ prop ] = this.params[ key ][ prop ]; } } break; case 'array': // Only update these if the new templatedata has an // array that isn't empty if ( Array.isArray( this.params[ key ][ prop ] ) && this.params[ key ][ prop ].length > 0 ) { result.params[ name ][ prop ] = this.params[ key ][ prop ]; } else { // If the new array is empty, delete it from the original delete result.params[ name ][ prop ]; } break; default: // Check if there's a value in the model if ( this.params[ key ][ prop ] !== undefined ) { const compareOrig = original.params[ oldKey ] && original.params[ oldKey ][ prop ]; if ( allProps[ prop ].allowLanguages ) { normalizedValue = this.propRemoveUnusedLanguages( this.params[ key ][ prop ] ); // Check if this should be displayed with language object or directly as string if ( this.isOutputInLanguageObject( compareOrig || {}, normalizedValue ) ) { result.params[ name ][ prop ] = normalizedValue; } else { // Store only one language as a string result.params[ name ][ prop ] = normalizedValue[ defaultLang ]; } } else if ( this.params[ key ][ prop ] || // Add empty strings only if the property existed before (empty or not) compareOrig !== undefined ) { // Set up the result result.params[ name ][ prop ] = this.params[ key ][ prop ]; } } break; } } } return result; }; /** * Check the key if it already exists in the parameter list. If it does, * find a new key that doesn't, and return it. * * @param {string} key New parameter key * @return {string} Valid new parameter key */ Model.prototype.getNewValidParameterKey = function ( key ) { if ( this.params[ key ] || this.getAllParamNames().indexOf( key ) !== -1 ) { // Change the key to be something else if ( /\d$/.test( key ) ) { key += '-'; } key += this.paramIdentifierCounter; this.paramIdentifierCounter++; return this.getNewValidParameterKey( key ); } return key; }; /** * Go over a language property and remove empty language key values * * @param {Object} propData Property data * @return {Object} Property data with only used language keys */ Model.prototype.propRemoveUnusedLanguages = function ( propData ) { const result = {}; if ( $.isPlainObject( propData ) ) { for ( const key in propData ) { if ( propData[ key ] ) { result[ key ] = propData[ key ]; } } } return result; }; /** * Check whether the output of the current parameter property should be * outputted in full language mode (object) or a simple string. * * @param {string|Object} originalPropValue Original property value * @param {string|Object} newPropValue New property value * @return {boolean} Output should be a full language object */ Model.prototype.isOutputInLanguageObject = function ( originalPropValue, newPropValue ) { if ( ( // The original was already split to languages typeof originalPropValue === 'object' && // Original was not an empty object !$.isEmptyObject( originalPropValue ) ) || ( // The new value is split to languages typeof newPropValue === 'object' && // New object is not empty !$.isEmptyObject( newPropValue ) && ( // The new value doesn't have the default language newPropValue[ this.getDefaultLanguage() ] === undefined || // There is more than just one language in the new property Object.keys( newPropValue ).length > 1 ) ) ) { return true; } return false; }; /** * Set the parameters that are available in the template source code * * @param {string[]} sourceParams Parameters available in template source */ Model.prototype.setSourceCodeParameters = function ( sourceParams ) { this.sourceCodeParameters = sourceParams; }; /** * Get the parameters that are available in the template source code * * @return {string[]} Parameters available in template source */ Model.prototype.getSourceCodeParameters = function () { return this.sourceCodeParameters; }; module.exports = Model;
| ver. 1.1 | |
.
| PHP 8.4.18 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка