function updatePagination(state = {
isFetching: false,
nextPageUrl: undefined,
pageCount: 0,
ids: []
}, action) {
switch (action.type) {
case requestType:
return merge({}, state, {
isFetching: true
})
case successType:
return merge({}, state, {
isFetching: false,
ids: union(state.ids, action.response.result),
nextPageUrl: action.response.nextPageUrl,
pageCount: state.pageCount + 1
})
case failureType:
return merge({}, state, {
isFetching: false
})
default:
return state
}
}
export default function courses(state = {
list: [],
is_fetching: false
}, action) {
switch (action.type) {
case actions.COURSES_REQUEST:
return merge({}, state, { is_fetching: true });
case actions.COURSES_SUCCESS:
return merge({}, state, { list: action.response, is_fetching: false });
case actions.COURSES_FAILURE:
return merge({}, state, { is_fetching: false });
case actions.APPEND_NEW_TOPIC:
return merge({}, state, { current: {
topics: [...state.current.topics, action.topic]
}});
case actions.REMOVE_TOPIC:
if (action.response.ok) {
return merge({}, state, { current: {
topics: state.current.topics.filter(t => t.id !== action.topicId)
}});
} else {
return state;
}
default:
return state;
}
}
function transaction(state=transactionInitialState, action={}) {
switch (action.type) {
case constants.RESET_TRANSACTION_FORM:
return merge({}, transactionInitialState);
case constants.APPEND_TRANSACTION_FORM:
return merge({}, state, { attributes: action.attributes });
case constants.VALIDATE_SCHEMA_FAILURE:
case constants.VALIDATE_TRANSACTION_FAILURE:
const { path, message } = errorDetail(action);
return merge({}, state, {
error: {
[path]: true,
message
}
});
case constants.VALIDATE_SCHEMA_FAILURE:
case constants.VALIDATE_TRANSACTION_REQUEST:
return merge({}, omit(state, 'error'), { error: {} });
default:
return state;
}
}
function UglifyWriter (inputNodes, options) {
if (!(this instanceof UglifyWriter)) {
return new UglifyWriter(inputNodes, options);
}
inputNodes = Array.isArray(inputNodes) ? inputNodes : [inputNodes];
Plugin.call(this, inputNodes, options);
this.options = merge({
mangle: true,
compress: true,
sourceMapIncludeSources: true
}, options);
this.sourceMapConfig = merge({
enabled: true,
extensions: ['js']
}, this.options.sourceMapConfig);
this.inputNodes = inputNodes;
var exclude = this.options.exclude;
if (Array.isArray(exclude)) {
this.excludes = new MatcherCollection(exclude);
} else {
this.excludes = MatchNothing;
}
}
function expense(state=expenseInitialState, action={}) {
switch (action.type) {
case constants.RESET_EXPENSE_FORM:
return merge({}, expenseInitialState);
case constants.APPEND_EXPENSE_FORM:
return merge({}, state, { attributes: action.attributes });
case constants.VALIDATE_SCHEMA_FAILURE:
case constants.VALIDATE_EXPENSE_FAILURE:
const { path, message } = errorDetail(action);
return merge({}, state, {
error: {
[path]: true,
message
}
});
case constants.VALIDATE_SCHEMA_FAILURE:
case constants.VALIDATE_EXPENSE_REQUEST:
return merge({}, omit(state, 'error'), { error: {} });
default:
return state;
}
}
function profile(state=profileInitialState, action={}) {
switch (action.type) {
case constants.SET_EDIT_MODE_PROFILE:
if (!action.isEditMode) {
return merge({}, profileInitialState, { isEditMode: action.isEditMode });
}
return merge({}, state, { isEditMode: action.isEditMode });
case constants.APPEND_PROFILE_FORM:
return merge({}, state, { attributes: action.attributes });
case constants.VALIDATE_PROFILE_REQUEST:
case constants.VALIDATE_DONATION_PROFILE_REQUEST:
return merge({}, omit(state, 'error'), { error: {} });
case constants.VALIDATE_PROFILE_FAILURE:
case constants.VALIDATE_DONATION_PROFILE_FAILURE:
const { path, message } = errorDetail(action);
return merge({}, state, {
error: {
[path]: true,
message
}
});
default:
return state;
}
}
export default function session(state={
user: {},
isAuthenticated: false
}, action={
hasPopOverMenuOpen: false
}) {
switch (action.type) {
case constants.DECODE_JWT_SUCCESS:
return merge({}, state, {
user: action.user,
isAuthenticated: true
});
case constants.DECODE_JWT_FAILURE:
case constants.DECODE_JWT_EMPTY:
return merge({}, state, {
isAuthenticated: false
});
case constants.SHOW_POPOVERMENU:
return merge({}, state, { hasPopOverMenuOpen: action.hasPopOverMenuOpen });
case constants.HYDRATE:
return merge({}, state, {
jwtExpired: action.data.jwtExpired,
jwtInvalid: action.data.jwtInvalid
});
default:
return state;
}
}
static moveEdgeNode(edge, nodeNum, x, y) {
let angle = this.calculateEdgeAngle(edge);
let newEdge = merge({}, edge, { display: (nodeNum == 1 ? { x1: x, y1: y } : { x2: x, y2: y }) });
let newAngle = this.calculateEdgeAngle(newEdge);
let deltaAngle = newAngle - angle;
let rotatedPoint = this.rotatePoint(edge.display.cx, edge.display.cy, deltaAngle);
return merge(newEdge, { display: { cx: rotatedPoint.x, cy: rotatedPoint.y } });
}
return values(nodes).reduce((result, node, i) => {
let angle = (2 * Math.PI) * (i / values(nodes).length);
return merge({}, result, {
[node.id]: merge({}, node, { display: {
x: x + Math.cos(angle) * radius,
y: y + Math.sin(angle) * radius
} })
});
}, {});
gulp.task('dist', ['dist-preprocess'], function() {
var env = merge({
__DEV_MODE__: false,
NODE_ENV: "\"production\""
}, options.env);
var plugins = [
new webpack.DefinePlugin(env),
new webpack.optimize.OccurenceOrderPlugin(),
new webpack.optimize.DedupePlugin()
];
var argv = require('yargs').argv;
if (!argv.skipMinify) {
plugins.push(new webpack.optimize.UglifyJsPlugin({
compress: {
warnings: false
}
}));
}
var config = extend({
plugins: plugins
}, webpackConfig, options.webpack || {});
if (!config.resolve) {
config.resolve = {};
}
if (!config.resolveLoader) {
config.resolveLoader = {};
}
if (options.webpack.module && options.webpack.module.loaders) {
webpackConfig.module.loaders.forEach(function(loader) {
config.module.loaders.push(loader);
});
}
config.resolve.extensions = merge(config.resolve.extensions || [],
['', '.js', '.json', '.htm', '.html', '.scss', '.md', '.svg']);
config.resolve.modulesDirectories = merge(config.resolve.modulesDirectories || [],
['node_modules/grommet/node_modules', 'node_modules']);
config.resolveLoader.modulesDirectories = merge(config.resolveLoader.modulesDirectories || [],
['node_modules/grommet/node_modules', 'node_modules']);
return gulp.src(options.mainJs)
.pipe(gulpWebpack(config))
.pipe(gulp.dest(dist));
});
static moveNode(graph, nodeId, x, y) {
let edges = this.edgesConnectedToNode(graph, nodeId);
// update the node
graph = merge({}, graph, { nodes: { [nodeId]: { display: { x, y } } } });
// then update the edges
return merge({}, graph, { edges: edges.reduce((result, edge) => {
let nodeNum = edge.node1_id == nodeId ? 1 : 2;
let newEdge = this.moveEdgeNode(edge, nodeNum, x, y);
return merge({}, result, { [edge.id]: this.updateEdgePosition(newEdge, graph) });
}, {}) });
}
const create = (enter, leave, setClass) => {
let move = merge({}, enter);
let addClass = merge({}, leave);
let removeClass = merge({}, enter);
let ngAnimateConsumable = $$fx.createAnimationsForSimilarEvents({enter, leave, move});
let classConsumables = $$fx.createClassAnimations({addClass, removeClass});
ngAnimateConsumable = merge(ngAnimateConsumable, classConsumables);
return ngAnimateConsumable;
};
_process: function(type, options) {
var modelOptions = merge({}, options, {
entity: {
name: inflection.singularize(options.entity.name)
}
});
var routeOptions = merge({}, options);
var self = this;
return this._processBlueprint(type, 'model', modelOptions)
.then(function() {
return self._processBlueprint(type, 'route', routeOptions);
});
}
styles.modifiers.forEach(function (modifierObj) {
var key = Object.keys(modifierObj)[0];
var modifier = modifierObj[key];
if (activeModifiers[key]) {
var modifierValue = activeModifiers[key];
var activeModifier;
if (typeof modifierValue === 'string') {
activeModifier = modifier[modifierValue];
} else if (modifierValue === true || modifierValue === false) {
activeModifier = modifier;
} else {
return;
}
if (!activeModifier) {
return;
}
merge(
modifierStyles,
activeModifier
);
}
});
MarkdownColor.prototype.generateTokens = function (renderer) {
var defaultTokens = {
// ember-cli styles
option: {
name: 'option',
token: '--option',
pattern: /((--\w*\b)|(<options>))/g,
render: renderStylesFactory(renderer, 'cyan')
},
default: {
name: 'default',
token: '(Default: default)',
pattern: /(\(Default:\s.*\))/g,
render: renderStylesFactory(renderer, 'cyan')
},
required: {
name: 'required',
token: '(Required)',
pattern: /(\(Required\))/g,
render: renderStylesFactory(renderer, 'cyan')
}
};
var colorTokens = unshiftValue(colors.concat(backgroundColors).map(getToken), {}).reduce(setToken);
return merge(colorTokens, defaultTokens);
};
export default function position(state = initState, action) {
switch (action.type) {
case NEW_GRAPH:
return merge({}, state, { currentId: action.graph.id });
case LOAD_GRAPH:
return merge({}, state, { loadedId: action.id });
case SHOW_GRAPH:
return merge({}, state, { currentId: action.id });
default:
return state;
}
};
_getDisjunctiveFacetSearchParams: function(state, facet, hierarchicalRootLevel) {
var facetFilters = this._getFacetFilters(state, facet, hierarchicalRootLevel);
var numericFilters = this._getNumericFilters(state, facet);
var tagFilters = this._getTagFilters(state);
var additionalParams = {
hitsPerPage: 1,
page: 0,
attributesToRetrieve: [],
attributesToHighlight: [],
attributesToSnippet: [],
tagFilters: tagFilters
};
var hierarchicalFacet = state.getHierarchicalFacetByName(facet);
if (hierarchicalFacet) {
additionalParams.facets = this._getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, hierarchicalRootLevel);
} else {
additionalParams.facets = facet;
}
if (state.distinct === true || state.distinct === false) {
additionalParams.distinct = state.distinct;
}
if (numericFilters.length > 0) {
additionalParams.numericFilters = numericFilters;
}
if (facetFilters.length > 0) {
additionalParams.facetFilters = facetFilters;
}
return merge(state.getQueryParams(), additionalParams);
},
_getHitsSearchParams: function(state) {
var facets = state.facets
.concat(state.disjunctiveFacets)
.concat(this._getHitsHierarchicalFacetsAttributes(state));
var facetFilters = this._getFacetFilters(state);
var numericFilters = this._getNumericFilters(state);
var tagFilters = this._getTagFilters(state);
var additionalParams = {
facets: facets,
tagFilters: tagFilters
};
if (state.distinct === true || state.distinct === false) {
additionalParams.distinct = state.distinct;
}
if (facetFilters.length > 0) {
additionalParams.facetFilters = facetFilters;
}
if (numericFilters.length > 0) {
additionalParams.numericFilters = numericFilters;
}
return merge(state.getQueryParams(), additionalParams);
},
static prepareNodes(graph) {
let nodes = values(graph.nodes).reduce((result, node) => {
return merge({}, result, { [node.id]: Node.setDefaults(node) });
}, {});
return merge({}, graph, { nodes: nodes });
}
function entities(state = initialState, action) {
if (action.response && action.response.entities) {
return merge({}, state, action.response.entities);
}
return state;
}
function normalizeParams(params) {
var result = merge({}, params);
if (result.query && (typeof result.query === 'object')) {
result.query = result.query.fullText;
}
return result;
}
function OracleQueryStream(connection, sql, bindings, options) {
Readable.call(this, merge({}, {
objectMode: true,
highWaterMark: 1000
}, options));
this.oracleReader = connection.reader(sql, bindings || []);
}
var _setStyleState = function (component, key, newState) {
var existing = component.state && component.state._radiumStyleState || {};
var state = { _radiumStyleState: clone(existing) };
state._radiumStyleState[key] = state._radiumStyleState[key] || {};
merge(state._radiumStyleState[key], newState);
component.setState(state);
};
componentWillReceiveProps: function(props) {
var suggestions = this.filteredSuggestions(this.state.query, props.suggestions);
this.setState({
suggestions: suggestions,
classNames: merge({}, DefaultClassNames, props.classNames)
});
},
var tiles = this.state.tiles.map(function (tile) {
if (tile.wide) {
return merge(tile, {params: {count: count}});
} else {
return tile;
}
});
_getMediaQueryStyles: function (styles) {
if (!Array.isArray(styles.mediaQueries) || !this.context || !this.context.mediaQueries) {
return styles;
}
var mediaQueryStyles = merge({}, styles);
var componentMediaQueries = this.context.mediaQueries;
styles.mediaQueries.forEach(function (mediaQueryObj) {
var key = Object.keys(mediaQueryObj)[0];
var mediaQuery = mediaQueryObj[key];
if (componentMediaQueries &&
componentMediaQueries[key] &&
componentMediaQueries[key].matches) {
var activeMediaQuery = mediaQuery;
if (!activeMediaQuery) {
return;
}
merge(
mediaQueryStyles,
activeMediaQuery
);
}
});
return mediaQueryStyles;
},
function MenuBuilder(opts) {
this.opts = merge({
appName: 'Camunda Modeler',
state: {
dmn: false,
bpmn: false,
undo: false,
redo: false,
editable: false,
searchable: false,
zoom: false,
save: false,
closable: false,
elementsSelected: false,
dmnRuleEditing: false,
dmnClauseEditingfalse: false,
exportAs: false,
development: app.developmentMode,
devtools: false
}
}, opts);
if (this.opts.template) {
this.menu = Menu.buildFromTemplate(this.opts.template);
} else {
this.menu = new Menu();
}
}
return this.addons.reduce(function(config, addon) {
if (addon.config) {
merge(config, addon.config(env, config));
}
return config;
}, initialConfig);
constructor(props) {
super(props);
this._onSubmit = this._onSubmit.bind(this);
this._onChange = this._onChange.bind(this);
this._onServerHardwareChange = this._onServerHardwareChange.bind(this);
this._onServerHardwareSearch = this._onServerHardwareSearch.bind(this);
this._onServerHardwareSearchResponse =
this._onServerHardwareSearchResponse.bind(this);
this._onFirmwareChange = this._onFirmwareChange.bind(this);
this._onFirmwareSearch = this._onFirmwareSearch.bind(this);
this._onFirmwareSearchResponse = this._onFirmwareSearchResponse.bind(this);
this._onAddConnection = this._onAddConnection.bind(this);
this._onNewConnectionOpen = this._onNewConnectionOpen.bind(this);
this._onNewConnectionClose = this._onNewConnectionClose.bind(this);
this._onRemoveConnection = this._onRemoveConnection.bind(this);
this._onAddVolume = this._onAddVolume.bind(this);
this._onNewVolumeOpen = this._onNewVolumeOpen.bind(this);
this._onNewVolumeClose = this._onNewVolumeClose.bind(this);
this._onRemoveVolume = this._onRemoveVolume.bind(this);
this.state = {
serverProfile: merge({}, props.serverProfile),
serverHardwareSuggestions: [],
firmwareSuggestions: []
};
}
static addInterlocks(graph, node1Id, node2Id, data) {
let nodes = data.nodes;
let edges = data.edges;
let n1 = graph.nodes[node1Id];
let n2 = graph.nodes[node2Id];
let x1 = n1.display.x;
let y1 = n1.display.y;
let x2 = n2.display.x;
let y2 = n2.display.y;
let midX = (x1 + x2)/2;
let midY = (y1 + y2)/2;
let angle = Math.atan2(x1 - x2, y2 - y1);
let num = Object.keys(nodes).length;
let spacing = Math.max(50, 200 - (num * 10));
nodes = nodes.reduce((result, node, i) => {
node.display.x = midX + Math.cos(angle) * (-(num-1)*spacing/2 + i*spacing);
node.display.y = midY + Math.sin(angle) * (-(num-1)*spacing/2 + i*spacing)
assign(result, { [node.id]: Node.setDefaults(node) });
return result;
}, {});
let graphWithNodes = merge({}, graph, { nodes });
edges.forEach((edge, i) => {
graphWithNodes = this.addEdge(graphWithNodes, edge);
});
return graphWithNodes;
}