/**
* Given a path somewhere within the tree, list the keys found if it is an object.
*
* @param command The command received from the reactotron app.
*/
function requestKeys(command: any) {
const trackedNode = trackedNodes[command.mstNodeName || "default"]
const atPath: string = (command && command.payload && command.payload.path) || []
if (trackedNode && trackedNode.node && atPath) {
const state = getSnapshot(trackedNode.node)
if (isNilOrEmpty(atPath)) {
reactotron.stateKeysResponse(null, keys(state))
} else {
const keyList = keys(dotPath(atPath, state))
reactotron.stateKeysResponse(atPath, keyList)
}
}
}
const extractSchemaMetaData = (typeDefs: string) => {
if (!cache.schemaMetaData) {
const scalars = keys(scalarResolversMap)
const scalarsPresentInSchema = map(hasScalar(typeDefs), scalars)
cache.schemaMetaData = zipObj(scalars, scalarsPresentInSchema)
}
return cache.schemaMetaData
}
/**
* Return a immutable model
* @param model An object with key value pair
*/
static getImmutableModel(model) {
let newModel: any = { };
const getFields = R.keys();
const assignFields = field => newModel[field] = model[field];
const prepareModel = R.pipe(getFields, R.forEach(assignFields));
prepareModel(model);
return newModel;
}
export const initAll = (element: any): any => {
if (Array.isArray(element)) {
return init(element);
// Check for length of Object.keys, because Dates and null are objects too
} else if (typeof element === 'object' && keys(element).length > 0) {
return map(initAll, element);
}
return element;
};
constructor(operator$: Stream<string>) {
const xs = Stream;
operator$.addListener(dummyListener);
this.operator$ =
operator$
.map(operator => xs.of(operators[operator]))
.flatten();
this.operators$ =
xs.of(keys(operators)).remember();
}
export function getPidByPidCode (pidstring: string) : PID|null {
let names:Array<string> = keys(PIDS);
let pidname:string = find((name:string) => {
let curpid:PID = PIDS[name];
return curpid.getPid() === pidstring;
})(names);
if (pidname) {
return PIDS[pidname];
} else {
return null;
}
};
fields.forEach(field => {
if (!toFilter) {
if (R.is(Object, field)) {
const key = R.head(R.keys(field));
const value = R.values(field);
if (key === 'eq') {
toFilter = (obj[value] === query);
}
} else {
if (!R.isNil(obj[field])) {
toFilter = obj[field].toString()
.toLowerCase().indexOf(query) > -1
}
}
}
});
function recordTimings(start: [number, number], name: string, timings: Record<string, [number, number]>, middlewareMetrics: Record<string, [number, number]>) {
// Capture the total amount of time spent in this middleware
const end = process.hrtime(start)
timings[name] = end
const label = `middleware-${name}`
metrics.batch(label, end)
// This middleware has added it's own metrics
// Just add them to `timings` scoped by the middleware's name and batch them
const middlewareMetricsKeys: string[] = keys(middlewareMetrics) as string[]
if (middlewareMetricsKeys.length > 0) {
forEach((k: string) => {
const metricEnd = middlewareMetrics[k]
const metricName = `${label}-${k}`
timings[metricName] = metricEnd
metrics.batch(metricName, metricEnd)
}, middlewareMetricsKeys)
}
}
export const nativeTypeDefs = (metaData: SchemaMetaData) => reduce(
(acc, scalar) => !metaData[scalar] ? `${acc}\nscalar ${scalar}\n` : acc,
'',
keys(scalarResolversMap)
)
export const process = (user: User): User => {
return Object.assign({ }, user, {
$tenants: R.keys(user.tenants),
});
}
