export function createSetters(fields: Array<any[]> | {[name: string]: any[]}, options?: Options = {}): {[name: string]: Setter} { if (Array.isArray(fields)) { fields = keyBy(fields, path => camelCase('set ' + normalize(last(path)))) } return mapValues(fields, (path, name) => createSetter(path, options)) }
export const mergeOptions = (defaults, opt, state) => mapValues( merge({}, defaults, opt), (v, k, { params = {} }) => { if (isReserved(k)) return v return result(v, params, state) } )
const dataToParamVectorItems = function (params, data) { const items = [] forEach(params, (param, name) => { if (Array.isArray(data[name]) && getType(param) !== 'array') { const values = [] if (data[name].length === 1) { // One value, no need to engage cross-product data[name] = data[name].pop() } else { forEach(data[name], value => { values.push({[name]: reduceXoObject(value, name)}) }) if (values.length) { // No values at all items.push({ type: 'set', values }) } delete data[name] } } }) if (Object.keys(data).length) { items.push({ type: 'set', values: [mapValues(data, reduceXoObject)] }) } return items }
Parser.prototype.clean = function() { this.symbols = this.symbols.filter(this.filterByProto, this); var byLine = groupBy(this.symbols, 'range_line'); var singleLines = mapValues(byLine, function(symbols) { return sortBy(symbols, function(symbol) { return symbol.range_column; }).shift(); }); this.symbols = map(singleLines, function(v, k) { return v; }).filter(function(symbol) { var tag = this.byId.tags[symbol.id]; var parent = this.byId.tags[symbol.parent]; if ((/^\</).test(tag.name)) { return false; } return ( tag.type || (parent && parent.origin['!data'].isPlainObject) || tag.origin['!data'].type ); }, this); };
LoggingWinston.prototype.log = function(levelName, msg, metadata, callback) { if (is.fn(metadata)) { callback = metadata; metadata = {}; } if (this.levels_[levelName] === undefined) { throw new Error('Unknown log level: ' + levelName); } var levelCode = this.levels_[levelName]; var stackdriverLevel = STACKDRIVER_LOGGING_LEVEL_CODE_TO_NAME[levelCode]; var entryMetadata = { resource: this.resource_, }; // Stackdriver Logs Viewer picks up the summary line from the `message` // property of the jsonPayload. // https://cloud.google.com/logging/docs/view/logs_viewer_v2#expanding. // // For error messages at severity 'error' and higher, Stackdriver // Error Reporting will pick up error messages if the full stack trace is // included in the textPayload or the message property of the jsonPayload. // https://cloud.google.com/error-reporting/docs/formatting-error-messages // We prefer to format messages as jsonPayload (by putting it as a message // property on an object) as that works is accepted by Error Reporting in // for more resource types. // // TODO(ofrobots): when resource.type is 'global' we need to additionally // provide serviceContext.service as part of the entry for Error Reporting to // automatically pick up the error. if (metadata && metadata.stack) { msg += (msg ? ' ' : '') + metadata.stack; } var data = { message: msg }; if (is.object(metadata)) { data.metadata = this.inspectMetadata_ ? mapValues(metadata, util.inspect) : metadata; // If the metadata contains a httpRequest property, promote it to the entry // metadata. This allows Stackdriver to use request log formatting. // https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#HttpRequest // Note that the httpRequest field must properly validate as HttpRequest // proto message, or the log entry would be rejected by the API. We no do // validation here. if (metadata.httpRequest) { entryMetadata.httpRequest = metadata.httpRequest; delete data.metadata.httpRequest; } } var entry = this.log_.entry(entryMetadata, data); this.log_[stackdriverLevel](entry, callback); };
const NodeComponent = ({attributes, children, node}: nodeProps) => { return ( <Tag {...attributes} data-slate-type={Tag} style={mapValues(stylesAttr, (val) => val && val(node))} >{children}</Tag> ); };
parse: function (data) { return mapValues(data, function (value, key) { // transform children and collections properties if (typeof value === 'string' && (key in this._children || key in this._collections)) { return {'@id': value}; } else { return value; } }.bind(this)); },
set.subs = (subfields, options = {}) => { let suboptions = { ...options, domain: domain || '' } if (options.domain) suboptions.domain += '.' + options.domain if (Array.isArray(subfields)) subfields = subfields.map(subpath => [...path, ...subpath]) else subfields = mapValues(subfields, subpath => [...path, ...subpath]) return createSetters(subfields, suboptions) }
constructor(...args) { super(...args); // Get the initial state from the `default*` props. const instanceInitialState = mapKeys(pickDefaults(this.props), fromDefaultName); const childProps = merge(instanceInitialState, omitDefaults(this.props)); this.state = merge(instanceInitialState, initialize(childProps)); // Create bound versions of the action creators. this.boundActionCreators = mapValues(actionCreators, fn => fn.bind(this)); }
const MarkComponent = ({ attributes, children, mark }: nodeProps) => { return ( <Tag {...attributes} style={mapValues(stylesAttr, val => val && val(mark))} data-slate-type={Tag} > {children} </Tag> ); };
return ({ attributes, children, node }: nodeProps) => { return ( <td style={Object.assign(mapValues(stylesAttr, val => val && val(node)), { minWidth: "50px" })} {...attributes} > {children} </td> ); };
export default (prefix = '', resources) => mapValues(resources, (endpoints) => ({ model: endpoints[0] && endpoints[0].model ? exportSchema(endpoints[0].model) : undefined, endpoints: map(endpoints, (endpoint) => ({ name: endpoint.name, method: endpoint.method.toUpperCase(), successCode: endpoint.successCode, path: prefix ? `${prefix}${endpoint.path}` : endpoint.path, instance: endpoint.instance })) }) )
export default function controllable(...args) { // Support [Python-style decorators](https://github.com/wycats/javascript-decorators) if (args.length === 1) return Component => controllable(Component, ...args); const [Component, propsOrStateManager] = args; let {reducers, initialize = noOpInitialize} = createStateManager(propsOrStateManager); // Create action creators from the reducers. const actionCreators = mapValues(reducers, reducer => { return function(...args) { // Calculate the new state. const currentProps = merge(this.state, omitDefaults(this.props), this.boundActionCreators); const newState = reducer(currentProps, ...args); // Update the state. this.setState(newState); // If there are callbacks for the changed values, invoke them. keys(newState).forEach(prop => { const newValue = newState[prop]; const callbackName = toCallbackName(prop); const cb = this.props[callbackName]; if (cb) cb(newValue); }); }; }); return class ControllableWrapper extends React.Component { constructor(...args) { super(...args); // Get the initial state from the `default*` props. const instanceInitialState = mapKeys(pickDefaults(this.props), fromDefaultName); const childProps = merge(instanceInitialState, omitDefaults(this.props)); this.state = merge(instanceInitialState, initialize(childProps)); // Create bound versions of the action creators. this.boundActionCreators = mapValues(actionCreators, fn => fn.bind(this)); } render() { const props = merge(this.state, omitDefaults(this.props), this.boundActionCreators); return <Component {...props} />; } }; }
module.exports = (fruit, basedir) => promiseAllObject( mapValues( template(fruit), (srcOrTransform, file) => { var resolved = path.resolve(basedir, file); return fs.exists(resolved) .then(exists => { if(exists) { return fs.readFile(resolved).then(orig => srcOrTransform(orig)); } else { return srcOrTransform; } }) .then(src => fs.writeFile(resolved, src)); } ) );
export default function(Tag, blockType, stylesAttr = nodeAttrs) { return { deserialize(el, next) { if (blockType && el.tagName && el.tagName.toLowerCase() === Tag) { let data = {} if (el.style.textAlign) { data.align = el.style.textAlign; } if (el.style.lineHeight) { data.lineHeight = el.style.lineHeight; } if (el.style.paddingLeft) { data.indent = el.style.paddingLeft; } if (Object.keys(data).length > 0) { return { object: 'block', type: blockType, data, nodes: next(el.childNodes), } } return { object: 'block', type: blockType, nodes: next(el.childNodes), } } }, serialize(obj, children) { if (obj.object == 'block' && obj.type === blockType) { return ( <Tag style={mapValues(stylesAttr, (val) => val && val(obj))}> {children} </Tag> ); } } } }
export default (config, state) => { return { ...config, services: mapValues(config.services, (service, serviceName) => { if (state.services[serviceName] && state.services[serviceName]._develop) { return { ...service, volumes: [ ...service.volumes || [], `${process.env.HOME}:${process.env.HOME}`, ], } } return service }), } }
var queryize = function (original) { var query = {}; // bind all mutators directly to query var proto = mapValues(mutators, function (fn) { return typeof fn === 'function' ? fn.bind(query) : fn; }); // mix in the bound mutators Object.assign(query, proto); query._constructor = queryize; query._isQueryizeObject = true; query._attributes = { debugEnabled: false, database: false, tableName: false, fromSubquery: false, alias: false, dataBindings: {}, useBoundParameters: queryize.useBoundParameters, where: [], whereBoolean: null, set: [], setKeys: {}, columns: [ '*' ], joins: [], orderBy: false, groupBy: false, distinct: false, limit: false, asName: false, builder: false }; if (original) { if (original._isQueryizeObject) { Object.assign(query._attributes, original.export()); } else if (typeof original === 'object') { Object.assign(query._attributes, original); } } return query; };
export default function(Tag, markType, stylesAttr = markAttrs) { return { deserialize(el, next) { if (markType && el.tagName && el.tagName.toLowerCase() === Tag) { let data = {} if (el.style.backgroundColor) { data.color = el.style.backgroundColor; } if (el.style.color) { data.color = el.style.color; } if (el.style.fontSize) { data.fontSize = el.style.fontSize; } if (el.style.letterSpacing) { data.letterSpacing = el.style.letterSpacing; } return { object: 'mark', type: markType, data, nodes: next(el.childNodes), } } }, serialize(obj, children) { if (obj.object == 'mark' && obj.type === markType) { return ( <Tag style={mapValues(stylesAttr, (val) => val && val(obj))}> {children} </Tag> ); } } } }
'use strict'; const ServiceTester = require('../service-tester'); const colorscheme = require('../../lib/colorscheme.json'); const mapValues = require('lodash.mapvalues'); const t = new ServiceTester({ id: 'website', title: 'website' }); module.exports = t; const colorsB = mapValues(colorscheme, 'colorB'); t.create('status of http://shields.io') .get('/http/shields.io.json?style=_shields_test') .expectJSON({ name: 'website', value: 'online', colorB: colorsB.brightgreen }); t.create('status of https://shields.io') .get('/https/shields.io.json?style=_shields_test') .expectJSON({ name: 'website', value: 'online', colorB: colorsB.brightgreen }); t.create('status of nonexistent domain') .get('/https/shields-io.io.json?style=_shields_test') .expectJSON({ name: 'website', value: 'offline', colorB: colorsB.red }); t.create('status when network is off') .get('/http/shields.io.json?style=_shields_test') .networkOff() .expectJSON({ name: 'website', value: 'offline', colorB: colorsB.red }); t.create('custom online label, online message and online color') .get('-up-down-green-grey/http/online.com.json?style=_shields_test&label=homepage') .intercept(nock => nock('http://online.com') .head('/')
function Demo (material, opts) { if (!(this instanceof Demo)) return new Demo(material, opts) if (!material) throw Error('Must specify a material') if (!opts) opts = {} if (!opts.initial) opts.initial = mapvalues(material.styles, 'default') if (!opts.root) opts.root = document.body if (!opts.background) opts.background = [0.05, 0.05, 0.05] if (!opts.complex) { opts.complex = bunny opts.complex.positions = opts.complex.positions.map(function (p) { return [p[0], p[1] - 4, p[2]] }) } if (!opts.canvas) { opts.canvas = document.createElement('canvas') opts.root.appendChild(opts.canvas) } window.addEventListener('resize', fit(opts.canvas), false) var gl = Context(opts.canvas, tick) var scene = Scene(gl, {background: opts.background}) var shapes = [ { id: 'shape', complex: opts.complex, flatten: opts.flatten, position: [0, 0, 0], material: 'example', style: opts.initial } ] var lights = [ { position: [10, 10, 10, 1], style: {color: [1, 1, 1], intensity: 10.0, ambient: 1.0, radius: 30} } ] scene.shapes(shapes) scene.lights(lights) scene.materials({example: material}) scene.init() var camera = orbit(opts.canvas) camera.lookAt([0, 0, 20], [0, 0, 0], [0, 0, 1]) var t = 0 function tick () { scene.draw(camera) scene.select('#shape').rotation(t, [0, 1, 0]) t += 0.0075 } var inputs = [] foreach(material.styles, function (value, key) { switch (value.type) { case 'vec3': inputs.push({type: 'color', label: key, format: 'array', initial: opts.initial[key]}) break case 'float': inputs.push({type: 'range', label: key, min: value.min, max: value.max, initial: opts.initial[key]}) break case 'bool': inputs.push({type: 'checkbox', label: key, initial: opts.initial[key]}) break } }) var link = '<a href="https://npmjs.org/gl-lambert-material">gl-material-' + material.name + '</a>' var panel = control(inputs, {position: 'top-right', theme: 'dark', width: 300, title: link} ) panel.on('input', function (data) { var style = {} foreach(data, function (value, key) { style[key] = value }) scene.select('#shape').style(style) }) }
function eachResource(resource) { if (!resource.view) return var clientViewPath = __dirname + '/../client/plugins/' + resource.name + '/' , templatePath = __dirname + '/templates/view/' , checksumPath = __dirname + '/../client/plugins/.' + resource.name + '.md5' , oldChecksum, newChecksum; var voidElements = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr']; var attributes = toArray(mapValues(resource.model.attributes, function(value, key) { var inputElementAttributes = value.inputElementAttributes || {} if (!inputElementAttributes.type) inputElementAttributes.type = 'text' return { id: uuid(), lowercase: key.toLowerCase(), capitalized: caps(key), type: value.type, remove: value.remove || false, model: value.model ? { title: find(resources, { name: value.model }).view.titleField, name: value.model, capitalized: caps(value.model) } : false, inputElement: value.inputElement || 'input', inputIsNotVoidElement: !contains(voidElements, value.inputElement || 'input'), inputElementAttributes: inputElementAttributes } })); var viewConfig = { name: resource.name, nameCapitalized: caps(resource.name), nameAllCaps: resource.name.toUpperCase(), titleField: resource.view.titleField, teaserFields: returnAttributes(resource.view.teaserFields), detailFields: returnAttributes(resource.view.detailFields), attributes: attributes }; function returnAttributes(fields) { var toReturn = []; for (var x in fields) toReturn.push(find(attributes, { lowercase: fields[x] })); return toReturn; } async.waterfall([ // Read checksum from existing view plugin function(cb) { fs.readFile(checksumPath, { encoding: 'utf8' }, function (err, checksum) { return cb(null, checksum); }) }, // Assign to oldChecksum and read files to create newChecksum function(md5, cb) { oldChecksum = md5 || null; if (isNull(oldChecksum)) return cb(null, null) dirsum.digest(clientViewPath, 'md5', cb); }, // Assign newChecksum and compare, if the same delete plugin folder function(hashes, cb) { if (isNull(oldChecksum)) return cb(null) newChecksum = hashes.hash; if (oldChecksum !== newChecksum) return cb(new Error('Checksum mismatch.')) deleteFolder(clientViewPath); cb(null); }, // Check if plugin folder exists function(cb) { fs.lstat(clientViewPath, function(err, folderStats) { if (err) return cb(null, false) cb(null, folderStats.isDirectory()); }) }, // If folder doesn't exists create it function(exists, cb) { if (exists) return cb(null) fs.mkdir(clientViewPath, cb) }, // List files in template directory function(cb) { fs.readdir(templatePath, cb); }, // Write template files function(files, cb) { async.each(files, function(file, cb) { fs.readFile(templatePath + file, { encoding: 'utf8' }, function(err, template) { if (err) return cb(err); hbTemplate = Handlebars.compile(template); fs.writeFile(clientViewPath + file.replace('.hbs', ''), hbTemplate(viewConfig), cb); }) }, cb); }, // Get new checksum function(cb) { dirsum.digest(clientViewPath, 'md5', cb); }, // Write new checksum function(hashes, cb) { fs.writeFile(checksumPath, hashes.hash, cb); } ], function(err){ if (err) console.error(err); }) }
} // __ _ // /__\ __ _ _ __ __| | ___ _ __ ___ // / \/// _` | '_ \ / _` |/ _ \| '_ ` _ \ // / _ \ (_| | | | | (_| | (_) | | | | | | // \/ \_/\__,_|_| |_|\__,_|\___/|_| |_| |_| // // map to random data generator (Chance) hazy.random = mapValues(hazy.meta.random.types, (value, key) => { const hazyRandObj = {} forEach(value, (v) => { hazyRandObj[v] = (conf) => new Chance()[v](conf) }) return hazyRandObj }) // ___ _ _ _ // / __\_ _(_) | __| | // /__\// | | | | |/ _` | // / \/ \ |_| | | | (_| | // \_____/\__,_|_|_|\__,_| // // creates a clone of the current hazy object (shallow, new memory references) hazy.fork = () => Object.assign({}, hazy)
const reducer = (state, action) => { let newState = rootReducer(state, action); // update cached ownState of root store rootState = newState; // FIXME: this reducer will also be responsible for handling queries // Specifically, it should update the relevant viewedStateSpec // FIXME: update state *before* calling root reducer if (action.type === MOUNT) { // add the initial own state of the mounted store to the root store's // state newState = immutable.set( newState, action.payload.path, action.payload.initialState ); // prime the cached state for the mounted store updateCachedState( action.payload.path, _get(newState, action.payload.path) ); // bypass mounted reducers for this action return newState; } else if (action.type === UNMOUNT) { // remove the unmounted store's own state from the root store's state newState = immutable.del(newState, action.payload.path); delete mounts[action.payload.path]; } else if (action.type === QUERY_RESULT) { let mount = mounts[action.payload.path]; let queriedStateSpec = _mapValues( action.payload.result, result => () => _get(rootState, result) ); mount.viewedStateSpec = _assign({}, mount.viewedStateSpec, queriedStateSpec); } // FIXME: calculate this array at mount/unmount time // iterate over mounted reducers, breadth-first let paths = []; for (const path in mounts) { paths.push(path.split('.')); } paths = paths.sort( (pathA, pathB) => { return pathA.length - pathB.length; }) .map(path => path.join('.')); function updateMountCache(path) { const mount = mounts[path]; const ownState = _get(newState, path); const viewedState = getViewedState(path); if (ownState !== mount.cache.ownState || viewedState !== mount.cache.viewedState ) { // either the mount's own state or its viewed state have changed, // so recalculate its merged state updateCachedState(path, ownState); } } paths.forEach(path => { const mount = mounts[path]; if (!mount.reducer) { // if `mount` has been called for a path, but the corresponding // mounted store creator *not* called, then no reducer will be // registered, so skip that path return; } updateMountCache(path); const newMergedState = mount.reducer.call(null, mount.cache.mergedState, action); if (newMergedState !== mount.cache.mergedState) { // FIXME: check that viewed state is not modified // FIXME: test that asserts that removed viewedState is reapplied mount.cache.mergedState = _merge(newMergedState, mount.cache.viewedState); mount.cache.ownState = _omit(newMergedState, Object.keys(mount.viewedStateSpec)); newState = immutable.set(newState, path, mount.cache.ownState); } }); // update cached state for all mounts paths.forEach(updateMountCache); return newState; };
export const mergeOptions = (defaults, opt) => { return mapValues(merge({}, opt, defaults), (v, k, { params }) => { if (isReserved(k)) return v return result(v, params) }) }
const getErrorFields = (err) => { if (!err.errors) return return mapValues(err.errors, getError) }
} return true; }) .argv, glob = argv._[0] || process.cwd(), maxDepth = argv.maxDepth; if (isNumber(maxDepth)) { argv.maxDepth = Math.floor(maxDepth); } argv = mapValues(argv, function (value) { if (isString(value)) { return value.replace(/\\/g, ''); } return value; }) markdownIndex(glob, argv) .then(function (data) { var inject = argv.inject, output = argv.output; if (inject) { return markdownIndex.inject(inject, data) .then(function () { console.log('Injected TOC into %s', inject); }); }
function parseBundle (bundleContent) { const ast = acorn.parse(bundleContent, { sourceType: 'script', // I believe in a bright future of ECMAScript! // Actually, it's set to `2050` to support the latest ECMAScript version that currently exists. // Seems like `acorn` supports such weird option value. ecmaVersion: 2050 }) const walkState = { locations: null } walk.recursive( ast, walkState, { CallExpression (node, state, c) { if (state.sizes) return const args = node.arguments // Additional bundle without webpack loader. // Modules are stored in second argument, after chunk ids: // webpackJsonp([<chunks>], <modules>, ...) // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name. if ( node.callee.type === 'Identifier' && args.length >= 2 && isArgumentContainsChunkIds(args[0]) && isArgumentContainsModulesList(args[1]) ) { state.locations = getModulesLocationFromFunctionArgument(args[1]) return } // Additional bundle without webpack loader, with module IDs optimized. // Modules are stored in second arguments Array(n).concat() call // webpackJsonp([<chunks>], Array([minimum ID]).concat([<module>, <module>, ...])) // As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name. if ( node.callee.type === 'Identifier' && (args.length === 2 || args.length === 3) && isArgumentContainsChunkIds(args[0]) && isArgumentArrayConcatContainingChunks(args[1]) ) { state.locations = getModulesLocationFromArrayConcat(args[1]) return } // Main bundle with webpack loader // Modules are stored in first argument: // (function (...) {...})(<modules>) if ( node.callee.type === 'FunctionExpression' && !node.callee.id && args.length === 1 && isArgumentContainsModulesList(args[0]) ) { state.locations = getModulesLocationFromFunctionArgument(args[0]) return } // Additional bundles with webpack 4 are loaded with: // (window.webpackJsonp=window.webpackJsonp||[]).push([[chunkId], [<module>, <module>], [[optional_entries]]]); if ( isWindowPropertyPushExpression(node) && args.length === 1 && isArgumentContainingChunkIdsAndModulesList(args[0]) ) { state.locations = getModulesLocationFromFunctionArgument(args[0].elements[1]) return } // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack // features (e.g. `umd` library output) can wrap modules list into additional IIFE. args.forEach(arg => c(arg, state)) } } ) if (!walkState.locations) { return null } return { src: bundleContent, modules: mapValues(walkState.locations, loc => bundleContent.slice(loc.start, loc.end) ) } }
'use strict' const chalk = require('chalk') const mapValues = require('lodash.mapvalues') const colorscheme = require('../lib/colorscheme.json') const colorsMap = mapValues(colorscheme, 'colorB') const { floorCount } = require('./color-formatters') const { loadServiceClasses } = require('../services') const serviceClasses = loadServiceClasses() const legacyServices = serviceClasses .map(cls => (typeof cls.registerLegacyRouteHandler === 'function' ? 1 : 0)) .reduce((a, b) => a + b) const newServices = serviceClasses.length - legacyServices const percentDone = ((newServices / serviceClasses.length) * 100).toFixed(2) const color = floorCount(percentDone, 10, 50, 100) console.log(`Found ${serviceClasses.length} services:`) console.log(`- ${legacyServices} legacy services`) console.log(`- ${newServices} new services`) console.log(chalk.hex(colorsMap[color])(`${percentDone}% done`))
const makeMixinsConfig = colors => ({ mixins: { ...mapValues(selectors, selector => selector(colors)), }, })
import {createAction} from 'redux-actions'; import mapValues from 'lodash.mapvalues'; import {Activity} from '../constants/ActionTypes'; import * as apiActions from './api'; const actions = { [Activity.getHistory]: () => apiActions.get(`/history?page=1&pageSize=15&sortKey=date&sortDir=desc`), [Activity.getQueue]: () => apiActions.get(`/queue?sort_by=timeleft&order=asc`), }; module.exports = mapValues(actions, (action, type) => createAction(type, action));