Ivan Starkov istarkov

## 01 toPower.md

      
              2 files
            
          
              0 forks
            
          
                0 comments
              
            
              0 stars
            
          
                istarkov
                / 01 toPower.md
            
            
              Created
              November 28, 2015 11:35
            
          
    Similar js toExponential method, but returns result in power format, instead of Xe-1 it returns X⋅10⁻¹
Usage example:
console.log(toPower(3, 111)); // out 1.110⋅10²
console.log(toPower(3, 0.00000000000000123)); //out 1.230⋅10⁻¹⁵

  
## proxy.js
// How to check array access
const arr = [];

const proxiedArr = new Proxy(arr, {
  set(target, name, value) {
    console.log(target, name, value);
    // console.trace();
    target[name] = value;
    return value;
  },

## unknown.md

      
              1 file
            
          
              0 forks
            
          
                0 comments
              
            
              0 stars
            
          
                istarkov
                / unknown.md
            
            
              Last active
              September 19, 2016 17:06
            
          
insist - настаивать
apart - кроме
posess - обладать
considerably - изрядно, конкретно
disclose раскрыть (секрет)
complain жаловаца
urgent срочный


## objectPathGet.js
// no string get
const get = (fn, def) => {
  try {
    return fn();
  } catch (e) {
    return def;
  }
};

// usage example

## withProps.js
// change output type of withProps
// from `HOC<A & B, B>` to `HOC<{ ...$Exact<B>, ...A }, B>`
type EnhancedCompProps = { b: number }

const enhancer2: HOC<*, EnhancedCompProps> = compose(
  withProps(({ b }) => ({
    b: `${b}`,
  })),
  withProps(({ b }) => ({
    // $ExpectError The operand of an arithmetic operation must be a number

## enhancedBase.js
/* @flow */
import React from 'react'
import { compose, defaultProps, withProps } from 'recompose'
import type { HOC } from 'recompose';

// type of Enhanced component props
type EnhancedComponentProps = {
  text?: string,
};

## HOCBase.js
// Extract type from any enhancer
type HOCBase_<A, B, C: HOC<A, B>> = A
type HOCBase<C> = HOCBase_<*, *, C>

## UseHocBase.js
type MyComponentProps = HOCBase<typeof myEnhancer>

class MyComponent extends React.Component<MyComponentProps> {
  render() ...
}

const MyEnhancedComponent = myEnhancer(MyComponent)

## simpleTypedEnhancer.js
/* @flow */
import * as React from 'react'
import { compose, withProps } from 'recompose'
import type { HOC } from 'recompose'

function mapProps<BaseProps: {}, EnhancedProps>(
  mapperFn: EnhancedProps => BaseProps
): (React.ComponentType<BaseProps>) => React.ComponentType<EnhancedProps> {
  return Component => props => <Component {...mapperFn(props)} />
}

## classBasedEnhancer.js
/* @flow */
import * as React from 'react'
import { compose, withProps } from 'recompose'
import type { HOC } from 'recompose'
// Example of very dirty written fetcher enhancer
function fetcher<Response: {}, Base: {}>(
  dest: string,
  nullRespType: ?Response
): HOC<{ ...$Exact<Base>, data?: Response }, Base> {
  return BaseComponent =>
	// How to check array access
	const arr = [];

	const proxiedArr = new Proxy(arr, {
	set(target, name, value) {
	console.log(target, name, value);
	// console.trace();
	target[name] = value;
	return value;
	},
	// no string get
	const get = (fn, def) => {
	try {
	return fn();
	} catch (e) {
	return def;
	}
	};

	// usage example
	// change output type of withProps
	// from `HOC<A & B, B>` to `HOC<{ ...$Exact<B>, ...A }, B>`
	type EnhancedCompProps = { b: number }

	const enhancer2: HOC<*, EnhancedCompProps> = compose(
	withProps(({ b }) => ({
	b: `${b}`,
	})),
	withProps(({ b }) => ({
	// $ExpectError The operand of an arithmetic operation must be a number
	/* @flow */
	import React from 'react'
	import { compose, defaultProps, withProps } from 'recompose'
	import type { HOC } from 'recompose';

	// type of Enhanced component props
	type EnhancedComponentProps = {
	text?: string,
	};
	// Extract type from any enhancer
	type HOCBase_<A, B, C: HOC<A, B>> = A
	type HOCBase<C> = HOCBase_<, , C>
	type MyComponentProps = HOCBase<typeof myEnhancer>

	class MyComponent extends React.Component<MyComponentProps> {
	render() ...
	}

	const MyEnhancedComponent = myEnhancer(MyComponent)
	/* @flow */
	import * as React from 'react'
	import { compose, withProps } from 'recompose'
	import type { HOC } from 'recompose'

	function mapProps<BaseProps: {}, EnhancedProps>(
	mapperFn: EnhancedProps => BaseProps
	): (React.ComponentType<BaseProps>) => React.ComponentType<EnhancedProps> {
	return Component => props => <Component {...mapperFn(props)} />
	}