How to use isKeyOfType method in Playwright Internal

1// @flow
2
3import React, { PureComponent } from 'react'
4import isEqual from 'lodash.isequal'
5import ClickOutside from 'react-click-outside'
6
7import Button from './Button'
8
9const cmz = require('cmz')
10
11const cx = {
12  editor: cmz(`
13    width: 100%
14  `),
15
16  link: cmz(`
17    & {
18      text-decoration: none
19      color: inherit
20    }
21
22    &:hover {
23      text-decoration: underline
24    }
25  `),
26
27  button: cmz(`
28    margin-top: 10px
29    margin-right: 10px
30  `),
31
32  warningMessage: cmz(`
33    padding: 10px 0
34  `)
35}
36
37const KEY_CODES = {
38  ENTER: 13,
39  ESCAPE: 27
40}
41
42const isKeyOfType = (keyCode: number, type: number) => keyCode === type
43
44export type EditorProps = {
45  value: any,
46  onValueChange(data: any): any
47}
48
49export type PresenterProps = {
50  value: any,
51  isEditable: boolean,
52  isHover: boolean,
53  activateEditingMode(): any
54}
55
56type Props = {
57  /** Component's value */
58  value: any,
59  /** To control whether the component can be editable or not */
60  isEditable: boolean,
61  /** To control whether the component begins in presenter mode or edit mode */
62  initialMode: 'present' | 'edit',
63  /** To control whether the component can be saved or not */
64  isValid: boolean,
65  /** To control whether the component will save changes on Enter or not, the Shift+Enter combination works always */
66  shouldSaveOnEnter: boolean,
67  /** Editing mode render function */
68  editor(props: EditorProps): any,
69  /** Presentation mode render function */
70  presenter(props: PresenterProps): any,
71  /** On save changes callback */
72  onSave(data: any): any,
73  /** On cancel changes callback */
74  onCancel?: () => void,
75}
76
77type State = {
78  editValue: any,
79  isInEditMode: boolean,
80  isHover: boolean
81}
82
83/**
84 * A generic component that provides inline editing functionality to any component.
85 */
86class InlineEditor extends PureComponent<Props, State> {
87  static defaultProps = {
88    isEditable: true,
89    initialMode: 'present',
90    isValid: true,
91    shouldSaveOnEnter: true
92  }
93
94  state = {
95    isInEditMode: this.props.initialMode === 'edit',
96    isHover: false,
97    editValue: this.props.value
98  }
99
100  componentWillReceiveProps (nextProps: Props) {
101    const { value } = nextProps
102    if (this.props.value !== value && this.state.editValue !== value) {
103      this.setState({ editValue: value })
104    }
105  }
106
107  renderControls = () => {
108    const { editValue } = this.state
109    const { value, isValid } = this.props
110
111    return (
112      <div>
113        <Button
114          className={cx.button}
115          type='button'
116          size='small'
117          rounded
118          onClick={this.handleSaveClick}
119          disabled={isEqual(editValue, value) || !isValid}
120        >
121          Save
122        </Button>
123        <Button
124          className={cx.button}
125          type='button'
126          size='small'
127          rounded
128          color='silver'
129          onClick={this.handleCancelClick}
130        >
131          Cancel
132        </Button>
133      </div>
134    )
135  }
136
137  setEditing = (isInEditMode: boolean) => {
138    let update = { isInEditMode }
139    if (!isInEditMode) {
140      update = {
141        ...update,
142        isHover: false
143      }
144    }
145    this.setState(update)
146  }
147
148  handleContainerClick = () => {
149    if (this.state.isInEditMode) {
150      this.abortChanges()
151    }
152  }
153
154  handleComponentClick = (event: Object) => {
155    if (this.state.isInEditMode) {
156      event.stopPropagation()
157    }
158  }
159
160  handleKeyDown = (event: Object) => {
161    const { keyCode } = event
162    const { shouldSaveOnEnter } = this.props
163    const { ENTER, ESCAPE } = KEY_CODES
164
165    const saveChanges = shouldSaveOnEnter
166      ? isKeyOfType(keyCode, ENTER)
167      : event.shiftKey && isKeyOfType(keyCode, ENTER)
168
169    if (saveChanges) {
170      this.saveChanges()
171    } else if (isKeyOfType(keyCode, ESCAPE)) {
172      this.abortChanges()
173    }
174  }
175
176  handleSaveClick = (event: Object) => {
177    event.stopPropagation()
178    this.saveChanges()
179  }
180
181  saveChanges = () => {
182    const { editValue } = this.state
183    const { onSave, isValid } = this.props
184
185    if (isValid) {
186      this.setEditing(false)
187
188      if (onSave) {
189        onSave(editValue)
190      }
191    }
192  }
193
194  abortChanges = () => {
195    const { value, onCancel } = this.props
196
197    this.setState({
198      editValue: value,
199      isInEditMode: false,
200      isHover: false
201    })
202
203    if (onCancel) {
204      onCancel()
205    }
206  }
207
208  handleCancelClick = (event: Object) => {
209    event.stopPropagation()
210    this.abortChanges()
211  }
212
213  handleClickOutside = () => {
214    this.abortChanges()
215  }
216
217  handleValueChange = (value: any) => {
218    this.setState({ editValue: value })
219  }
220
221  handleActivateEditingMode = () => {
222    if (this.props.isEditable) {
223      this.setEditing(true)
224    }
225  }
226
227  handleMouseEnter = () => {
228    this.setState({ isHover: true })
229  }
230
231  handleMouseLeave = () => {
232    this.setState({ isHover: false })
233  }
234
235  renderContent = () => {
236    const { editValue, isHover, isInEditMode } = this.state
237    const { editor, presenter, isEditable } = this.props
238    const mainComponentRenderer = isInEditMode ? editor : presenter
239    const props = {
240      value: editValue,
241      onValueChange: this.handleValueChange,
242      activateEditingMode: this.handleActivateEditingMode,
243      isEditable,
244      isHover
245    }
246
247    return (
248      <div
249        onClick={this.handleContainerClick}
250        onKeyDown={this.handleKeyDown}
251        onMouseEnter={this.handleMouseEnter}
252        onMouseLeave={this.handleMouseLeave}
253      >
254        <div onClick={this.handleComponentClick}>
255          {mainComponentRenderer && mainComponentRenderer(props)}
256        </div>
257        {isInEditMode && this.renderControls()}
258      </div>
259    )
260  }
261
262  render () {
263    return this.state.isInEditMode
264      ? (
265        <div className={cx.editor}>
266          <ClickOutside onClickOutside={this.handleClickOutside}>
267            {this.renderContent()}
268          </ClickOutside>
269        </div>
270      ) : this.renderContent()
271  }
272}
273
274export default InlineEditor
275

Source: InlineEditor.js

// @flow

import React, { PureComponent } from 'react'
import isEqual from 'lodash.isequal'
import ClickOutside from 'react-click-outside'

import Button from './Button'

const cmz = require('cmz')

const cx = {
  editor: cmz(`
    width: 100%
  `),

  link: cmz(`
    & {
      text-decoration: none
      color: inherit
    }

    &:hover {
      text-decoration: underline
    }
  `),

  button: cmz(`
    margin-top: 10px
    margin-right: 10px
  `),

  warningMessage: cmz(`
    padding: 10px 0
  `)
}

const KEY_CODES = {
  ENTER: 13,
  ESCAPE: 27
}

const isKeyOfType = (keyCode: number, type: number) => keyCode === type

export type EditorProps = {
  value: any,
  onValueChange(data: any): any
}

export type PresenterProps = {
  value: any,
  isEditable: boolean,
  isHover: boolean,
  activateEditingMode(): any
}

type Props = {
  /** Component's value */
  value: any,
  /** To control whether the component can be editable or not */
  isEditable: boolean,
  /** To control whether the component begins in presenter mode or edit mode */
  initialMode: 'present' | 'edit',
  /** To control whether the component can be saved or not */
  isValid: boolean,
  /** To control whether the component will save changes on Enter or not, the Shift+Enter combination works always */
  shouldSaveOnEnter: boolean,
  /** Editing mode render function */
  editor(props: EditorProps): any,
  /** Presentation mode render function */
  presenter(props: PresenterProps): any,
  /** On save changes callback */
  onSave(data: any): any,
  /** On cancel changes callback */
  onCancel?: () => void,
}

type State = {
  editValue: any,
  isInEditMode: boolean,
  isHover: boolean
}

/**
 * A generic component that provides inline editing functionality to any component.
 */
class InlineEditor extends PureComponent<Props, State> {
  static defaultProps = {
    isEditable: true,
    initialMode: 'present',
    isValid: true,
    shouldSaveOnEnter: true
  }

  state = {
    isInEditMode: this.props.initialMode === 'edit',
    isHover: false,
    editValue: this.props.value
  }

  componentWillReceiveProps (nextProps: Props) {
    const { value } = nextProps
    if (this.props.value !== value && this.state.editValue !== value) {
      this.setState({ editValue: value })
    }
  }

  renderControls = () => {
    const { editValue } = this.state
    const { value, isValid } = this.props

    return (
      <div>
        <Button
          className={cx.button}
          type='button'
          size='small'
          rounded
          onClick={this.handleSaveClick}
          disabled={isEqual(editValue, value) || !isValid}
        >
          Save
        </Button>
        <Button
          className={cx.button}
          type='button'
          size='small'
          rounded
          color='silver'
          onClick={this.handleCancelClick}
        >
          Cancel
        </Button>
      </div>
    )
  }

  setEditing = (isInEditMode: boolean) => {
    let update = { isInEditMode }
    if (!isInEditMode) {
      update = {
        ...update,
        isHover: false
      }
    }
    this.setState(update)
  }

  handleContainerClick = () => {
    if (this.state.isInEditMode) {
      this.abortChanges()
    }
  }

  handleComponentClick = (event: Object) => {
    if (this.state.isInEditMode) {
      event.stopPropagation()
    }
  }

  handleKeyDown = (event: Object) => {
    const { keyCode } = event
    const { shouldSaveOnEnter } = this.props
    const { ENTER, ESCAPE } = KEY_CODES

    const saveChanges = shouldSaveOnEnter
      ? isKeyOfType(keyCode, ENTER)
      : event.shiftKey && isKeyOfType(keyCode, ENTER)

    if (saveChanges) {
      this.saveChanges()
    } else if (isKeyOfType(keyCode, ESCAPE)) {
      this.abortChanges()
    }
  }

  handleSaveClick = (event: Object) => {
    event.stopPropagation()
    this.saveChanges()
  }

  saveChanges = () => {
    const { editValue } = this.state
    const { onSave, isValid } = this.props

    if (isValid) {
      this.setEditing(false)

      if (onSave) {
        onSave(editValue)
      }
    }
  }

  abortChanges = () => {
    const { value, onCancel } = this.props

    this.setState({
      editValue: value,
      isInEditMode: false,
      isHover: false
    })

    if (onCancel) {
      onCancel()
    }
  }

  handleCancelClick = (event: Object) => {
    event.stopPropagation()
    this.abortChanges()
  }

  handleClickOutside = () => {
    this.abortChanges()
  }

  handleValueChange = (value: any) => {
    this.setState({ editValue: value })
  }

  handleActivateEditingMode = () => {
    if (this.props.isEditable) {
      this.setEditing(true)
    }
  }

  handleMouseEnter = () => {
    this.setState({ isHover: true })
  }

  handleMouseLeave = () => {
    this.setState({ isHover: false })
  }

  renderContent = () => {
    const { editValue, isHover, isInEditMode } = this.state
    const { editor, presenter, isEditable } = this.props
    const mainComponentRenderer = isInEditMode ? editor : presenter
    const props = {
      value: editValue,
      onValueChange: this.handleValueChange,
      activateEditingMode: this.handleActivateEditingMode,
      isEditable,
      isHover
    }

    return (
      <div
        onClick={this.handleContainerClick}
        onKeyDown={this.handleKeyDown}
        onMouseEnter={this.handleMouseEnter}
        onMouseLeave={this.handleMouseLeave}
      >
        <div onClick={this.handleComponentClick}>
          {mainComponentRenderer && mainComponentRenderer(props)}
        </div>
        {isInEditMode && this.renderControls()}
      </div>
    )
  }

  render () {
    return this.state.isInEditMode
      ? (
        <div className={cx.editor}>
          <ClickOutside onClickOutside={this.handleClickOutside}>
            {this.renderContent()}
          </ClickOutside>
        </div>
      ) : this.renderContent()
  }
}

export default InlineEditor

1const UnionType = require("./UnionType"); 
2const LiteralType = require("./LiteralType"); 
3const Type = require("./Type.js");
4const Utils = require("../core/Utils");
5class KeyofType extends UnionType{
6    constructor(target, referenceType){
7        super([],target);
8        this.isKeyofType = true;
9        this.referenceType = referenceType;
10        this.hasGenericType = !!referenceType.isGenericType;
11        this.elements = this.getTypeKeys(referenceType)
12    }
13    clone(inference){
14        if( !inference || !this.hasGenericType ){
15            return this;
16        }
17        const type = Utils.inferTypeValue( this.referenceType.type(), inference );
18        if( type !== this.referenceType ){
19            return new KeyofType(this.target, type );
20        }
21        return this;
22    }
23
24    getTypeKeys( type ){
25        type = type || this.referenceType;
26        if( type.isGenericType ){
27            return [];
28        }
29        const properties = new Set();
30        if( type ){
31            const push=(name,type)=>{
32                properties.add( new LiteralType( this.target.getGlobalTypeById(type), this.target, name) );
33            }
34            switch(true){
35                case type.isLiteralObjectType :
36                case type.isEnumType :
37                    type.attributes.forEach( (value,key)=>{
38                        push(key, 'string');
39                    });
40                break;
41                case type.isLiteralArrayType :
42                case type.isTupleUnion :
43                    type.elements.forEach( (value,key)=>{
44                        push(key, 'number');
45                    });
46                break;
47                case type.isIntersectionType : 
48                case type.isModule :
49                case type.isInstanceofType :
50                    type.getTypeKeys().forEach( key=>{
51                        push(key, 'string');
52                    });
53                break
54            }
55        }
56        return Array.from( properties.values() );
57    }
58    is(type, context){
59        if( !type || !(type instanceof Type) )return false;
60        if( !this.isNeedCheckType(type) )return true;
61        if( type.isAliasType ){
62            const inherit = type.inherit;
63            if( inherit && inherit.isUnionType ){
64                type = inherit;
65            }
66        }
67        const infer = type=>{
68            if( context && context.inference ){
69                return context.inference(type);
70            }
71            return type;
72        };
73        const elements = this.getTypeKeys( infer( this.referenceType ) );
74        if( !elements.length )return false; 
75        if( type.isUnionType ){
76            return type.elements.every( item=>{
77                const base = item.type();
78                return elements.some( child=>{
79                    const childType = child.type();
80                    if( base.isLiteralType ){
81                        return childType.isLiteralType ? base.value === childType.value : false;
82                    }
83                    return base.is(child.type(), context);
84                });
85            });
86        }
87       
88        return elements.some( base=>base.type().is(type, context) );
89    }
90    toString(context={}){
91        const refType = this.referenceType.type();
92        if( refType.hasGenericType ){
93            if( refType.isGenericType && refType.hasConstraint && !refType.inherit.hasGenericType ){
94                return `keyof ${refType.inherit.toString(context)}`;
95            }
96            return `keyof ${refType.toString(context)}`;
97        }
98        let elements = this.getTypeKeys( refType );
99        if( !elements.length ){
100            return 'never';
101        }
102        return elements.map( item=>item.type().toString(context) ).join(' | ');
103    }
104}
105module.exports = KeyofType;

Source: KeyofType.js

const UnionType = require("./UnionType"); 
const LiteralType = require("./LiteralType"); 
const Type = require("./Type.js");
const Utils = require("../core/Utils");
class KeyofType extends UnionType{
    constructor(target, referenceType){
        super([],target);
        this.isKeyofType = true;
        this.referenceType = referenceType;
        this.hasGenericType = !!referenceType.isGenericType;
        this.elements = this.getTypeKeys(referenceType)
    }
    clone(inference){
        if( !inference || !this.hasGenericType ){
            return this;
        }
        const type = Utils.inferTypeValue( this.referenceType.type(), inference );
        if( type !== this.referenceType ){
            return new KeyofType(this.target, type );
        }
        return this;
    }

    getTypeKeys( type ){
        type = type || this.referenceType;
        if( type.isGenericType ){
            return [];
        }
        const properties = new Set();
        if( type ){
            const push=(name,type)=>{
                properties.add( new LiteralType( this.target.getGlobalTypeById(type), this.target, name) );
            }
            switch(true){
                case type.isLiteralObjectType :
                case type.isEnumType :
                    type.attributes.forEach( (value,key)=>{
                        push(key, 'string');
                    });
                break;
                case type.isLiteralArrayType :
                case type.isTupleUnion :
                    type.elements.forEach( (value,key)=>{
                        push(key, 'number');
                    });
                break;
                case type.isIntersectionType : 
                case type.isModule :
                case type.isInstanceofType :
                    type.getTypeKeys().forEach( key=>{
                        push(key, 'string');
                    });
                break
            }
        }
        return Array.from( properties.values() );
    }
    is(type, context){
        if( !type || !(type instanceof Type) )return false;
        if( !this.isNeedCheckType(type) )return true;
        if( type.isAliasType ){
            const inherit = type.inherit;
            if( inherit && inherit.isUnionType ){
                type = inherit;
            }
        }
        const infer = type=>{
            if( context && context.inference ){
                return context.inference(type);
            }
            return type;
        };
        const elements = this.getTypeKeys( infer( this.referenceType ) );
        if( !elements.length )return false; 
        if( type.isUnionType ){
            return type.elements.every( item=>{
                const base = item.type();
                return elements.some( child=>{
                    const childType = child.type();
                    if( base.isLiteralType ){
                        return childType.isLiteralType ? base.value === childType.value : false;
                    }
                    return base.is(child.type(), context);
                });
            });
        }
       
        return elements.some( base=>base.type().is(type, context) );
    }
    toString(context={}){
        const refType = this.referenceType.type();
        if( refType.hasGenericType ){
            if( refType.isGenericType && refType.hasConstraint && !refType.inherit.hasGenericType ){
                return `keyof ${refType.inherit.toString(context)}`;
            }
            return `keyof ${refType.toString(context)}`;
        }
        let elements = this.getTypeKeys( refType );
        if( !elements.length ){
            return 'never';
        }
        return elements.map( item=>item.type().toString(context) ).join(' | ');
    }
}
module.exports = KeyofType;

1const Utils = require("../core/Utils");
2const Namespace = require("../core/Namespace");
3const Type = require("./Type");
4class TupleType extends Type{
5    constructor(inherit, elements , target, rest = false , isTupleUnion=false){
6        super("$TupleType",inherit);
7        this.elements = [].concat(elements);
8        const len = this.elements.length;
9        this.rest = rest;
10        this.requireCount = rest && len > 1 ? len-1 : len;
11        this.isTupleType = true;
12        this.prefix = !!(target && target.prefix);
13        this.isTupleUnion = isTupleUnion ? true : !!(target && target.isTypeTupleUnionDefinition);
14        this.target = target;
15    }
16
17    get hasGenericType(){
18        return this.elements.some( type=>{
19            type = type.type();
20            return type && type.hasGenericType;
21        });
22    }
23
24    attribute(index){
25        if( !(this.prefix || this.isTupleUnion) ){
26            return this.elements[ index ] || null;
27        }
28        return null;
29    }
30
31    dynamicAttribute( type ){
32        const arrClass = Namespace.globals.get('Array');
33        return arrClass && arrClass.dynamicProperties.get( Utils.getOriginType( type ) );
34    }
35
36    clone(inference){
37        if( !inference || !this.hasGenericType ){
38            return this;
39        }
40        const elements = this.elements.map( item=>{
41            return Utils.inferTypeValue(item.type(), inference);
42        });
43        return new TupleType(this.inherit,elements,this.target,this.rest, this.isTupleUnion);
44    }
45    checkItems(items, errorItems=[], context={} ){
46        const infer = type =>Utils.inferTypeValue(type, context.inference);
47        const errorHandler = context.errorHandler || ( result=>result );
48        const checkItem = (base, item, flag=true)=>{
49            const baseType = infer( base.type() );
50            const type = infer( item.type() );
51            if( ( base.isThisType || (base.target && base.target.isThisType) ) && !type.isInstanceofType ){
52                errorItems.push( item );
53                return flag ? errorHandler(false, baseType, item) : false;
54            }
55            if( baseType && !baseType.is( type, context ) ){
56                errorItems.push( item );
57                return flag ? errorHandler(false, baseType, item) : false;
58            }
59            return true;
60        }
61        if(this.prefix || this.rest || this.isTupleUnion){
62            return items.every( (item)=>{
63                return errorHandler(this.elements.some( base=>{
64                    return checkItem(base, item, false);
65                }), this.elements[0].type(), item);
66            });
67        }
68        const len = this.elements.length;
69        const rest = len > 0 ? this.elements[ len-1 ] : null;
70        const hasRest = rest && rest.type().rest;
71        const requireCount = hasRest ? this.requireCount-1 : this.requireCount;
72        if( (hasRest && items.length < requireCount) ){
73            return false;
74        }else if( !hasRest && items.length !== requireCount ){
75            return false;
76        }
77        return items.every( (item,index)=>{
78            let base = this.elements[index];
79            if( base && !(hasRest && base === rest) ){
80                return checkItem(base,item);
81            }else{
82                if( hasRest && rest ){
83                    return checkItem(rest,item);
84                }else{
85                    return errorHandler(this.elements.some( (base)=>{
86                        return checkItem(base,item,false);
87                    }), this.elements[0].type(), item );
88                }
89            }
90        });
91    }
92    is( type, context ){
93        if( !type || !(type instanceof Type) )return false;
94        if( !this.isNeedCheckType(type) )return true;
95        if( type.isAliasType ){
96            const inherit = type.inherit;
97            if( inherit && inherit.isTupleType ){
98                type = inherit;
99            }
100        }
101        if( this.isTupleUnion && !this.inherit.is(type.inherit, context) ){
102            return false;
103        }
104        let items = [];
105        if( type.isTupleType || type.isLiteralArrayType){
106            items =type.elements;
107        }else if( type.isClassGenericType && type.inherit === this.inherit ){
108            items = type.types;
109        }else if( !this.rest ){
110            return this.inherit.is(type, context);
111        }
112        return this.checkItems( items , [], context);
113    }
114    toString(context){
115        const isTupleUnion = this.isTupleUnion || this.elements.some( item=>{
116            let type = item.type();
117            if( type.isComputeType && !type.object.isThisType ){
118                type = type.property.type();
119            }
120            return !!type.isUnionType;
121        });
122        context = {parent:context,type:this,isTupleUnion};
123        const elements = this.elements.map( (item)=>{
124            return item.type().toString(context);
125        });
126        const rest = this.rest && this.target && !this.target.isRestElement ? '...' : '';
127        if( isTupleUnion ){
128            if( elements.length > 1 || ( (this.elements[0].isUnionType || this.elements[0].isKeyofType) && this.elements[0].elements.length > 1) ){
129                return `(${elements.join(" | ")})[]`;
130            }else{
131                return `${elements[0]}[]`;
132            }
133        }
134        if( elements.length === 1 && (this.prefix||this.rest) ){
135            return `${rest}${elements[0]}[]`;
136        }
137        return `${rest}[${elements.join(',')}]`;
138    }
139}
140module.exports = TupleType;

Source: TupleType.js

const Utils = require("../core/Utils");
const Namespace = require("../core/Namespace");
const Type = require("./Type");
class TupleType extends Type{
    constructor(inherit, elements , target, rest = false , isTupleUnion=false){
        super("$TupleType",inherit);
        this.elements = [].concat(elements);
        const len = this.elements.length;
        this.rest = rest;
        this.requireCount = rest && len > 1 ? len-1 : len;
        this.isTupleType = true;
        this.prefix = !!(target && target.prefix);
        this.isTupleUnion = isTupleUnion ? true : !!(target && target.isTypeTupleUnionDefinition);
        this.target = target;
    }

    get hasGenericType(){
        return this.elements.some( type=>{
            type = type.type();
            return type && type.hasGenericType;
        });
    }

    attribute(index){
        if( !(this.prefix || this.isTupleUnion) ){
            return this.elements[ index ] || null;
        }
        return null;
    }

    dynamicAttribute( type ){
        const arrClass = Namespace.globals.get('Array');
        return arrClass && arrClass.dynamicProperties.get( Utils.getOriginType( type ) );
    }

    clone(inference){
        if( !inference || !this.hasGenericType ){
            return this;
        }
        const elements = this.elements.map( item=>{
            return Utils.inferTypeValue(item.type(), inference);
        });
        return new TupleType(this.inherit,elements,this.target,this.rest, this.isTupleUnion);
    }
    checkItems(items, errorItems=[], context={} ){
        const infer = type =>Utils.inferTypeValue(type, context.inference);
        const errorHandler = context.errorHandler || ( result=>result );
        const checkItem = (base, item, flag=true)=>{
            const baseType = infer( base.type() );
            const type = infer( item.type() );
            if( ( base.isThisType || (base.target && base.target.isThisType) ) && !type.isInstanceofType ){
                errorItems.push( item );
                return flag ? errorHandler(false, baseType, item) : false;
            }
            if( baseType && !baseType.is( type, context ) ){
                errorItems.push( item );
                return flag ? errorHandler(false, baseType, item) : false;
            }
            return true;
        }
        if(this.prefix || this.rest || this.isTupleUnion){
            return items.every( (item)=>{
                return errorHandler(this.elements.some( base=>{
                    return checkItem(base, item, false);
                }), this.elements[0].type(), item);
            });
        }
        const len = this.elements.length;
        const rest = len > 0 ? this.elements[ len-1 ] : null;
        const hasRest = rest && rest.type().rest;
        const requireCount = hasRest ? this.requireCount-1 : this.requireCount;
        if( (hasRest && items.length < requireCount) ){
            return false;
        }else if( !hasRest && items.length !== requireCount ){
            return false;
        }
        return items.every( (item,index)=>{
            let base = this.elements[index];
            if( base && !(hasRest && base === rest) ){
                return checkItem(base,item);
            }else{
                if( hasRest && rest ){
                    return checkItem(rest,item);
                }else{
                    return errorHandler(this.elements.some( (base)=>{
                        return checkItem(base,item,false);
                    }), this.elements[0].type(), item );
                }
            }
        });
    }
    is( type, context ){
        if( !type || !(type instanceof Type) )return false;
        if( !this.isNeedCheckType(type) )return true;
        if( type.isAliasType ){
            const inherit = type.inherit;
            if( inherit && inherit.isTupleType ){
                type = inherit;
            }
        }
        if( this.isTupleUnion && !this.inherit.is(type.inherit, context) ){
            return false;
        }
        let items = [];
        if( type.isTupleType || type.isLiteralArrayType){
            items =type.elements;
        }else if( type.isClassGenericType && type.inherit === this.inherit ){
            items = type.types;
        }else if( !this.rest ){
            return this.inherit.is(type, context);
        }
        return this.checkItems( items , [], context);
    }
    toString(context){
        const isTupleUnion = this.isTupleUnion || this.elements.some( item=>{
            let type = item.type();
            if( type.isComputeType && !type.object.isThisType ){
                type = type.property.type();
            }
            return !!type.isUnionType;
        });
        context = {parent:context,type:this,isTupleUnion};
        const elements = this.elements.map( (item)=>{
            return item.type().toString(context);
        });
        const rest = this.rest && this.target && !this.target.isRestElement ? '...' : '';
        if( isTupleUnion ){
            if( elements.length > 1 || ( (this.elements[0].isUnionType || this.elements[0].isKeyofType) && this.elements[0].elements.length > 1) ){
                return `(${elements.join(" | ")})[]`;
            }else{
                return `${elements[0]}[]`;
            }
        }
        if( elements.length === 1 && (this.prefix||this.rest) ){
            return `${rest}${elements[0]}[]`;
        }
        return `${rest}[${elements.join(',')}]`;
    }
}
module.exports = TupleType;