{
fieldInstance: this,
originalEvent: event,
value: event.target.value
}
);
}
);
}
_handleFieldFocused(event) {
this.emit(
'fieldFocused',
{
fieldInstance: this,
originalEvent: event,
value: event.target.value
}
);
}
_internalValueFn() {
const {value} = this;
return value;
}
}
Soy.register(Text, templates);
export default Text;
/**
* Asserts that formatted data is valid. Throws error if item is not in the
* valid syntax.
* @param {*} item
* @protected
*/
assertItemObjectStructure_(item) {
if (!core.isObject(item)) {
throw new Promise.CancellationError('Autocomplete item must be an object');
}
if (!item.hasOwnProperty('textPrimary')) {
throw new Promise.CancellationError('Autocomplete item must be an object with \'textPrimary\' key');
}
}
}
Soy.register(Autocomplete, templates);
/**
* State definition.
* @type {!Object}
* @static
*/
Autocomplete.STATE = {
/**
* Activate or Deactivate the suggestion of the best align region. If true,
* the component will try to find a better region to align, otherwise,
* it will keep the position at the bottom.
* @type {boolean}
* @default true.
*/
autoBestAlign: {
if (expression) {
validation = validations.find(validation => validation.regex.test(expression));
}
return validation;
}
_updateValue() {
const value = this._getValue();
this.setState(
{
value
},
() => this._emitFieldEdited(value)
);
}
_validationsValueFn() {
let {dataType} = this;
dataType = dataType == 'string' ? dataType : 'numeric';
return this._normalizeValidationsOptions(VALIDATIONS[dataType]);
}
}
Soy.register(Validation, templates);
export default Validation;
this._handleOptionEdited(event, 'label');
}
_handleOptionValueEdited(event) {
this._handleOptionEdited(event, 'value');
}
_internalItemsValueFn() {
const options = this.getCurrentLocaleValue();
return this.getItems(options || []);
}
_setValue(value = {}) {
const {defaultLanguageId} = this;
const formattedValue = {...value};
for (const languageId in value) {
if (defaultLanguageId !== languageId) {
formattedValue[languageId] = formattedValue[languageId]
.filter(({value}) => !!value);
}
}
return formattedValue;
}
}
Soy.register(Options, templates);
export default Options;
import Component from 'metal-component';
import Soy from 'metal-soy';
import templates from './fieldset.soy';
/**
* Fieldset Component
*/
class Fieldset extends Component {}
// Register component
Soy.register(Fieldset, templates, 'render');
if (!window.DDMFieldset) {
window.DDMFieldset = {
};
}
window.DDMFieldset.render = Fieldset;
export default Fieldset;
*
* @default undefined
* @instance
* @memberOf ChangeListsConfiguration
* @type {!string}
*/
urlConfiguration: Config.string().required(),
/**
* Path of the available icons.
*
* @default undefined
* @instance
* @memberOf ChangeListsConfiguration
* @type {!string}
*/
spritemap: Config.string().required(),
/**
* Content types that support change tracking.
*
* @instance
* @memberOf ChangeListsConfiguration
* @type {string}
*/
tooltipBody: Config.string()
};
Soy.register(ChangeListsConfiguration, templates);
export default ChangeListsConfiguration;
event.preventDefault();
return;
}
}
/**
* Setter for items attribute.
* @param {!Array<string>} items
* @protected
*/
setItems_(items) {
return items.map((item) => Soy.toIncDom(item));
}
}
Soy.register(Select, templates);
/**
* State definition.
* @type {!Object}
* @static
*/
Select.STATE = {
/**
* The CSS class used by the select menu arrow.
* @type {string}
* @default 'caret'
*/
arrowClass: {
value: 'caret'
},
import Component from 'metal-component';
import Soy from 'metal-soy';
import templates from './PageRenderer.soy.js';
import {Config} from 'metal-state';
class PageRenderer extends Component {}
PageRenderer.STATE = {
items: Config.arrayOf(
Config.shapeOf(
{
type: Config.string()
}
)
)
};
Soy.register(PageRenderer, templates);
export default PageRenderer;
}
}
/**
* State definition.
* @static
* @type {!Object}
*/
RotateComponent.STATE = {
/**
* Path of this module.
* @type {Function}
*/
modulePath: {
validator: core.isString
},
/**
* Injected method that notifies the editor that this component wants to
* generate a preview version of the image.
* @type {Function}
*/
requestImageEditorPreview: {
validator: core.isFunction
}
};
Soy.register(RotateComponent, componentTemplates);
export default RotateComponent;
/**
* The URL of a portlet to display the tags
* @default undefined
* @instance
* @memberof AssetVocabularyCategoriesSelector
* @review
* @type {?string}
*/
portletURL: Config.string(),
/**
* List of selected items
* @default undefined
* @instance
* @memberof AssetVocabularyCategoriesSelector
* @review
* @type {?Array}
*/
selectedItems: Config.array().value([]),
singleSelect: Config.bool().value(false),
vocabularyIds: Config.array().value([])
};
Soy.register(AssetVocabularyCategoriesSelector, templates);
export {AssetVocabularyCategoriesSelector};
export default AssetVocabularyCategoriesSelector;
/**
* State definition.
* @review
* @static
* @type {!Object}
*/
FloatingToolbarBackgroundImagePanel.STATE = {
/**
* @default undefined
* @memberof FloatingToolbarBackgroundImagePanel
* @review
* @type {!string}
*/
itemId: Config
.string()
.required()
};
const ConnectedFloatingToolbarBackgroundImagePanel = getConnectedComponent(
FloatingToolbarBackgroundImagePanel,
[
'imageSelectorURL',
'portletNamespace'
]
);
Soy.register(ConnectedFloatingToolbarBackgroundImagePanel, templates);
export {ConnectedFloatingToolbarBackgroundImagePanel, FloatingToolbarBackgroundImagePanel};
export default ConnectedFloatingToolbarBackgroundImagePanel;
spritemap: Config.string().required(),
/**
* @default strings
* @instance
* @memberof RuleList
* @type {!object}
*/
strings: Config.object().value(
{
'belongs-to': Liferay.Language.get('belongs-to'),
'calculate-field': Liferay.Language.get('calculate-field-x-as-x'),
contains: Liferay.Language.get('contains'),
'equals-to': Liferay.Language.get('is-equal-to'),
'greater-than': Liferay.Language.get('is-greater-than'),
'greater-than-equals': Liferay.Language.get('is-greater-than-or-equal-to'),
'is-empty': Liferay.Language.get('is-empty'),
'less-than': Liferay.Language.get('is-less-than'),
'less-than-equals': Liferay.Language.get('is-less-than-or-equal-to'),
'not-contains': Liferay.Language.get('does-not-contain'),
'not-equals-to': Liferay.Language.get('is-not-equal-to'),
'not-is-empty': Liferay.Language.get('is-not-empty')
}
)
};
Soy.register(RuleList, templates);
export default RuleList;
import Component from 'metal-component';
import Soy from 'metal-soy';
import './SidebarAvailableElements.es';
import templates from './SidebarElementsPanel.soy';
/**
* SidebarElementsPanel
*/
class SidebarElementsPanel extends Component {
}
/**
* State definition.
* @review
* @static
* @type {!Object}
*/
SidebarElementsPanel.STATE = {};
Soy.register(SidebarElementsPanel, templates);
export {SidebarElementsPanel};
export default SidebarElementsPanel;
import Component from 'metal-component';
import Footer from './Footer.soy';
import Header from './Header.soy';
import Soy from 'metal-soy';
import templates from './View.soy';
class View extends Component {}
// Register component
Soy.register(View, templates);
export default View;
*/
_toggleDropdown() {
const dropdownAction = this.openDropdown ?
this._closeDropdown :
this._openDropdown;
dropdownAction.call(this);
}
}
SegmentsExperienceSelector.STATE = {
modalStates: Config.object().value(null),
openDropdown: Config.bool().internal().value(false),
segmentsEntryId: Config.string().internal()
};
const ConnectedSegmentsExperienceSelector = getConnectedComponent(
SegmentsExperienceSelector,
[
'classPK',
'availableSegmentsExperiences',
'segmentsExperienceId',
'defaultSegmentsEntryId'
]
);
Soy.register(ConnectedSegmentsExperienceSelector, templates);
export {ConnectedSegmentsExperienceSelector};
export default ConnectedSegmentsExperienceSelector;
* @default default
* @type {?(string|undefined)}
*/
style: Config.oneOf(['accent', 'default', 'link', 'primary', 'success', 'danger', 'warning']).value(
'default'
),
/**
* @default undefined
* @type {?string}
*/
target: Config.oneOf(['_blank', '_self', '_parent', '_top']),
/**
* @default button
* @type {?string}
*/
type: Config.oneOf(['button', 'reset', 'submit']).value('button'),
/**
* @default undefined
* @type {?(string|undefined)}
*/
value: Config.string(),
};
Soy.register(Button, templates);
export {Button};
export default Button;
import Component from 'metal-component';
import Soy from 'metal-soy';
import templates from './validation.soy';
/**
* Validation Component
*/
class Validation extends Component {}
// Register component
Soy.register(Validation, templates, 'render');
if (!window.DDMValidation) {
window.DDMValidation = {};
}
window.DDMValidation.render = Validation;
export default Validation;
import Component from 'metal-component';
import Soy from 'metal-soy';
import templates from './text.soy';
/**
* Text Component
*/
class Text extends Component {}
// Register component
Soy.register(Text, templates, 'render');
if (!window.DDMText) {
window.DDMText = {};
}
window.DDMText.render = Text;
export default Text;
return fields.filter(({repeatable}) => repeatable === true);
}
}
Calculator.STATE = {
expression: Config.string().value(''),
fields: Config.arrayOf(
Config.shapeOf(
{
fieldName: Config.string(),
label: Config.string(),
repeatable: Config.bool(),
value: Config.string()
}
)
).value([]),
functions: Config.array().value([]),
index: Config.number().value(0),
repeatableFields: Config.array().valueFn('_repeatableFieldsValueFn'),
spritemap: Config.string().required()
};
Soy.register(Calculator, templates);
export default Calculator;
/**
* The width of the <img> element.
* @type {Number}
*/
imageWidth: Config.number().internal(),
/**
* Path to icon images.
* @type {String}
*/
spritemap: Config.string().required(),
/**
* Flag that indicate if 'zoom in' is disabled.
* @type {Boolean}
*/
zoomInDisabled: Config.bool().internal(),
/**
* Flag that indicate if 'zoom out' is disabled.
* @type {Boolean}
*/
zoomOutDisabled: Config.bool().internal()
};
Soy.register(ImagePreviewer, templates);
export {ImagePreviewer};
export default ImagePreviewer;
max: {
validator: core.isNumber,
value: 100
},
/**
* The minimum value of the progress bar. When the value is at its
* max, the bar will be fully collapsed.
* @type {number}
*/
min: {
validator: core.isNumber,
value: 0
},
/**
* The current value of the progress bar.
* @type {number}
*/
value: {
setter: 'setterValueFn_',
validator: core.isNumber,
value: 0
}
};
Soy.register(ProgressBar, templates);
export {ProgressBar};
export default ProgressBar;
* Flag to specify the logic for disabling inputs based on switch state
* @type {Boolean}
*/
disableOnChecked: {
validator: core.isBoolean,
value: true
},
/**
* CSS Selector for the inputs to enable/disable
* @type {String}
*/
inputSelector: {
validator: core.isString
},
/**
* Label of the switch
* @type {String}
*/
label: {
validator: core.isString
}
};
Soy.register(ToggleDisableInputs, templates);
export default ToggleDisableInputs;
* @default undefined
* @instance
* @memberOf LayoutPageTemplateSidebarAddedFragment
* @type {!number}
*/
index: Config.number().required(),
/**
* Fragment name
* @default undefined
* @instance
* @memberOf LayoutPageTemplateSidebarAddedFragment
* @type {!string}
*/
name: Config.string().required(),
/**
* Path of the available icons.
* @default undefined
* @instance
* @memberOf LayoutPageTemplateSidebarAddedFragment
* @type {!string}
*/
spritemap: Config.string().required(),
};
Soy.register(LayoutPageTemplateSidebarAddedFragment, templates);
export {LayoutPageTemplateSidebarAddedFragment};
export default LayoutPageTemplateSidebarAddedFragment;
* @private
* @review
*/
_handleLanguageChange(event) {
event.preventDefault();
this.store.dispatchAction(
CHANGE_LANGUAGE_ID,
{
languageId: event.delegateTarget.getAttribute('data-languageid')
}
);
}
}
const ConnectedTranslationStatus = getConnectedComponent(
TranslationStatus,
[
'availableLanguages',
'defaultLanguageId',
'languageId',
'spritemap',
'translationStatus'
]
);
Soy.register(ConnectedTranslationStatus, templates);
export {ConnectedTranslationStatus};
export default ConnectedTranslationStatus;
handleInputChangeEvent(event) {
const value = event.delegateTarget.checked;
this.setState({
value
});
this.emit('fieldEdited', {
fieldInstance: this,
originalEvent: event,
value
});
}
}
Soy.register(Checkbox, templates);
Checkbox.STATE = {
/**
* @default 'string'
* @instance
* @memberof Text
* @type {?(string|undefined)}
*/
dataType: Config.string().value('boolean'),
/**
* @default undefined
* @instance
* @memberof FieldBase
import Component from 'metal-component';
import Soy from 'metal-soy';
import templates from './rule-builder.soy';
let RuleBuilderTemplates = [];
if (!window.DDMRuleBuilder) {
window.DDMRuleBuilder = {
};
}
for (let template in templates) {
if (template !== 'templates') {
class C extends Component {};
Soy.register(C, templates, template);
RuleBuilderTemplates.push(
{
key: template,
component: C
}
);
window.DDMRuleBuilder[template] = C;
}
}
export default RuleBuilderTemplates;
/**
* @default undefined
* @memberof FloatingToolbarTextPropertiesPanel
* @review
* @type {!string}
*/
itemId: Config
.string()
.required(),
/**
* @default undefined
* @memberof FloatingToolbarTextPropertiesPanel
* @review
* @type {object}
*/
store: Config
.object()
.value(null)
};
const ConnectedFloatingToolbarTextPropertiesPanel = getConnectedComponent(
FloatingToolbarTextPropertiesPanel,
['themeColorsCssClasses']
);
Soy.register(ConnectedFloatingToolbarTextPropertiesPanel, templates);
export {ConnectedFloatingToolbarTextPropertiesPanel, FloatingToolbarTextPropertiesPanel};
export default FloatingToolbarTextPropertiesPanel;
*/
valueHeaderFn_() {
if (this.element) {
let wrapper = document.createElement('div');
for (let i = 0; i < this.element.childNodes.length; i++) {
if (dom.hasClass(this.element.childNodes[i], 'dropdown-menu')) {
break;
}
wrapper.appendChild(this.element.childNodes[i].cloneNode(true));
}
return wrapper.innerHTML;
}
return '';
}
}
Soy.register(Dropdown, templates);
/**
* State definition.
* @type {!Object}
* @static
*/
Dropdown.STATE = {
/**
* The current position of the tooltip after being aligned via `Align.align`.
* @type {number}
*/
alignedPosition: {
validator: Align.isValidPosition,
},
import Component from 'metal-component';
import Soy from 'metal-soy';
import templates from './checkbox-multiple.soy';
/**
* CheckboxMultiple Component
*/
class CheckboxMultiple extends Component {}
// Register component
Soy.register(CheckboxMultiple, templates, 'render');
if (!window.DDMCheckboxMultiple) {
window.DDMCheckboxMultiple = {
};
}
window.DDMCheckboxMultiple.render = CheckboxMultiple;
export default CheckboxMultiple;
* @static
* @type {!Object}
*/
SidebarWidgetsPanel.STATE = {
/**
* @default ''
* @instance
* @memberOf SidebarWidgetsPanel
* @private
* @review
* @type {string}
*/
_keywords: Config
.string()
.internal()
.value('')
};
const ConnectedSidebarWidgetsPanel = getConnectedComponent(
SidebarWidgetsPanel,
[
'spritemap',
'widgets'
]
);
Soy.register(ConnectedSidebarWidgetsPanel, templates);
export {ConnectedSidebarWidgetsPanel, SidebarWidgetsPanel};
export default ConnectedSidebarWidgetsPanel;