KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use provider method in pact-foundation-pact

Best JavaScript code snippet using pact-foundation-pact

ValueProviderFactory.js

Source:ValueProviderFactory.js

1///////////////////////////////////////////////////////////////////////////2// Copyright Â© 2014 - 2018 Esri. All Rights Reserved.3//4// Licensed under the Apache License Version 2.0 (the "License");5// you may not use this file except in compliance with the License.6// You may obtain a copy of the License at7//8//    http://www.apache.org/licenses/LICENSE-2.09//10// Unless required by applicable law or agreed to in writing, software11// distributed under the License is distributed on an "AS IS" BASIS,12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13// See the License for the specific language governing permissions and14// limitations under the License.15///////////////////////////////////////////////////////////////////////////16define([17  'dojo/_base/lang',18  'dojo/_base/array',19  'dojo/_base/declare',20  './BlankValueProvider',21  './SimpleValueProvider',22  './TwoNumbersValueProvider',23  './TwoDatesValueProvider',24  './ListValueProvider',25  './AdvancedListValueProvider',26  './PredefinedValueProvider',27  './NumberListValueProvider',28  './DateIsInValueProvider',29  'jimu/utils',30  'jimu/LayerInfos/LayerInfos'31],32  function(lang, array, declare, BlankValueProvider, SimpleValueProvider, TwoNumbersValueProvider,33    TwoDatesValueProvider,34    ListValueProvider,35    AdvancedListValueProvider,36    PredefinedValueProvider,37    NumberListValueProvider, DateIsInValueProvider, jimuUtils, LayerInfos) {38    var BLANK_VALUE_PROVIDER = "BLANK_VALUE_PROVIDER";39    var SIMPLE_VALUE_PROVIDER = "SIMPLE_VALUE_PROVIDER";40    var TWO_NUMBERS_VALUE_PROVIDER = "TWO_NUMBERS_VALUE_PROVIDER";41    var TWO_DATES_VALUE_PROVIDER = "TWO_DATES_VALUE_PROVIDER";42    var LIST_VALUE_PROVIDER = "LIST_VALUE_PROVIDER";43    var NUMBER_LIST_VALUE_PROVIDER = "NUMBER_LIST_VALUE_PROVIDER";44    var DATE_IS_IN_VALUE_PROVIDER = "DATE_IS_IN_VALUE_PROVIDER";45    var ADVANCED_LIST_VALUE_PROVIDER = "ADVANCED_LIST_VALUE_PROVIDER";46    var UNIQUE_PREDEFINED_VALUE_PROVIDER = "UNIQUE_PREDEFINED_VALUE_PROVIDER";47    var MULTIPLE_PREDEFINED_VALUE_PROVIDER = "MULTIPLE_PREDEFINED_VALUE_PROVIDER";48    //operator + type => value provider49    var relationship = {50      //string51      stringOperatorIs: {52        value: {53          normalProviderType: SIMPLE_VALUE_PROVIDER,54          codedValueProviderType: LIST_VALUE_PROVIDER,55          supportAskForValue: true,56          supportCaseSensitive: true57        },58        field: {59          normalProviderType: LIST_VALUE_PROVIDER60        },61        unique: {62          normalProviderType: LIST_VALUE_PROVIDER,63          supportAskForValue: true,64          filterCodedValueIfPossible: true65        },66        uniquePredefined:{67          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,68          supportAskForValue: true,69          supportCaseSensitive: true70        }71      },72      stringOperatorIsNot: {73        value: {74          normalProviderType: SIMPLE_VALUE_PROVIDER,75          codedValueProviderType: LIST_VALUE_PROVIDER,76          supportAskForValue: true,77          supportCaseSensitive: true78        },79        field: {80          normalProviderType: LIST_VALUE_PROVIDER81        },82        unique: {83          normalProviderType: LIST_VALUE_PROVIDER,84          supportAskForValue: true,85          filterCodedValueIfPossible: true86        },87        uniquePredefined:{88          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,89          supportAskForValue: true,90          supportCaseSensitive: true91        }92      },93      stringOperatorStartsWith: {94        value: {95          normalProviderType: SIMPLE_VALUE_PROVIDER,96          supportAskForValue: true,97          supportCaseSensitive: true98        },99        values:{100          normalProviderType: SIMPLE_VALUE_PROVIDER101        },102        uniquePredefined:{103          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,104          supportAskForValue: true,105          supportCaseSensitive: true106        },107        multiplePredefined:{108          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,109          supportAskForValue: true,110          supportCaseSensitive: true111        }112      },113      stringOperatorEndsWith: {114        value: {115          normalProviderType: SIMPLE_VALUE_PROVIDER,116          supportAskForValue: true,117          supportCaseSensitive: true118        },119        values:{120          normalProviderType: SIMPLE_VALUE_PROVIDER121        },122        uniquePredefined:{123          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,124          supportAskForValue: true,125          supportCaseSensitive: true126        },127        multiplePredefined:{128          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,129          supportAskForValue: true,130          supportCaseSensitive: true131        }132      },133      stringOperatorContains: {134        value: {135          normalProviderType: SIMPLE_VALUE_PROVIDER,136          supportAskForValue: true,137          supportCaseSensitive: true138        },139        values:{140          normalProviderType: SIMPLE_VALUE_PROVIDER141        },142        uniquePredefined:{143          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,144          supportAskForValue: true,145          supportCaseSensitive: true146        },147        multiplePredefined:{148          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,149          supportAskForValue: true,150          supportCaseSensitive: true151        }152      },153      stringOperatorDoesNotContain: {154        value: {155          normalProviderType: SIMPLE_VALUE_PROVIDER,156          supportAskForValue: true,157          supportCaseSensitive: true158        },159        values:{160          normalProviderType: SIMPLE_VALUE_PROVIDER161        },162        uniquePredefined:{163          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,164          supportAskForValue: true,165          supportCaseSensitive: true166        },167        multiplePredefined:{168          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,169          supportAskForValue: true,170          supportCaseSensitive: true171        }172      },173      stringOperatorIsAnyOf: {174        values:{175          normalProviderType: SIMPLE_VALUE_PROVIDER176        },177        multiple:{178          normalProviderType: ADVANCED_LIST_VALUE_PROVIDER,179          supportAskForValue: true,180          filterCodedValueIfPossible: true181        },182        multiplePredefined:{183          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,184          supportAskForValue: true185        }186      },187      stringOperatorIsNoneOf: {188        values:{189          normalProviderType: SIMPLE_VALUE_PROVIDER190        },191        multiple:{192          normalProviderType: ADVANCED_LIST_VALUE_PROVIDER,193          supportAskForValue: true,194          filterCodedValueIfPossible: true195        },196        multiplePredefined:{197          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,198          supportAskForValue: true199        }200      },201      stringOperatorIsBlank: {202        value: {203          normalProviderType: BLANK_VALUE_PROVIDER204        }205      },206      stringOperatorIsNotBlank: {207        value: {208          normalProviderType: BLANK_VALUE_PROVIDER209        }210      },211      //number212      numberOperatorIs: {213        value: {214          normalProviderType: SIMPLE_VALUE_PROVIDER,215          codedValueProviderType: LIST_VALUE_PROVIDER,216          supportAskForValue: true217        },218        field: {219          normalProviderType: LIST_VALUE_PROVIDER220        },221        unique: {222          normalProviderType: LIST_VALUE_PROVIDER,223          supportAskForValue: true,224          filterCodedValueIfPossible: true225        },226        uniquePredefined:{227          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,228          supportAskForValue: true229        }230      },231      numberOperatorIsNot: {232        value: {233          normalProviderType: SIMPLE_VALUE_PROVIDER,234          codedValueProviderType: LIST_VALUE_PROVIDER,235          supportAskForValue: true236        },237        field: {238          normalProviderType: LIST_VALUE_PROVIDER239        },240        unique: {241          normalProviderType: LIST_VALUE_PROVIDER,242          supportAskForValue: true,243          filterCodedValueIfPossible: true244        },245        uniquePredefined:{246          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,247          supportAskForValue: true248        }249      },250      numberOperatorIsAtLeast: {251        value: {252          normalProviderType: SIMPLE_VALUE_PROVIDER,253          supportAskForValue: true254        },255        field: {256          normalProviderType: LIST_VALUE_PROVIDER257        },258        unique: {259          normalProviderType: LIST_VALUE_PROVIDER,260          supportAskForValue: true,261          filterCodedValueIfPossible: true262        },263        uniquePredefined:{264          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,265          supportAskForValue: true266        }267      },268      numberOperatorIsLessThan: {269        value: {270          normalProviderType: SIMPLE_VALUE_PROVIDER,271          supportAskForValue: true272        },273        field: {274          normalProviderType: LIST_VALUE_PROVIDER275        },276        unique: {277          normalProviderType: LIST_VALUE_PROVIDER,278          supportAskForValue: true,279          filterCodedValueIfPossible: true280        },281        uniquePredefined:{282          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,283          supportAskForValue: true284        }285      },286      numberOperatorIsAtMost: {287        value: {288          normalProviderType: SIMPLE_VALUE_PROVIDER,289          supportAskForValue: true290        },291        field: {292          normalProviderType: LIST_VALUE_PROVIDER293        },294        unique: {295          normalProviderType: LIST_VALUE_PROVIDER,296          supportAskForValue: true,297          filterCodedValueIfPossible: true298        },299        uniquePredefined:{300          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,301          supportAskForValue: true302        }303      },304      numberOperatorIsGreaterThan: {305        value: {306          normalProviderType: SIMPLE_VALUE_PROVIDER,307          supportAskForValue: true308        },309        field: {310          normalProviderType: LIST_VALUE_PROVIDER311        },312        unique: {313          normalProviderType: LIST_VALUE_PROVIDER,314          supportAskForValue: true,315          filterCodedValueIfPossible: true316        },317        uniquePredefined:{318          normalProviderType: UNIQUE_PREDEFINED_VALUE_PROVIDER,319          supportAskForValue: true320        }321      },322      numberOperatorIsAnyOf: {323        values:{324          normalProviderType: SIMPLE_VALUE_PROVIDER325        },326        multiple:{327          normalProviderType: ADVANCED_LIST_VALUE_PROVIDER,328          supportAskForValue: true329        },330        multiplePredefined:{331          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,332          supportAskForValue: true333        }334      },335      numberOperatorIsNoneOf: {336        values:{337          normalProviderType: SIMPLE_VALUE_PROVIDER338        },339        multiple:{340          normalProviderType: ADVANCED_LIST_VALUE_PROVIDER,341          supportAskForValue: true342        },343        multiplePredefined:{344          normalProviderType: MULTIPLE_PREDEFINED_VALUE_PROVIDER,345          supportAskForValue: true346        }347      },348      numberOperatorIsBetween: {349        value: {350          normalProviderType: TWO_NUMBERS_VALUE_PROVIDER,351          supportAskForValue: true352        }353      },354      numberOperatorIsNotBetween: {355        value: {356          normalProviderType: TWO_NUMBERS_VALUE_PROVIDER,357          supportAskForValue: true358        }359      },360      numberOperatorIsBlank: {361        value: {362          normalProviderType: BLANK_VALUE_PROVIDER363        }364      },365      numberOperatorIsNotBlank: {366        value: {367          normalProviderType: BLANK_VALUE_PROVIDER368        }369      },370      //date371      dateOperatorIsOn: {372        value: {373          normalProviderType: SIMPLE_VALUE_PROVIDER,374          supportAskForValue: true375        },376        field: {377          normalProviderType: LIST_VALUE_PROVIDER378        }379        // Unique type can work already but we set it hidden in UI just right now.380        // ,381        // unique: {382        //   normalProviderType: LIST_VALUE_PROVIDER,383        //   supportAskForValue: true,384        //   filterCodedValueIfPossible: true385        // }386      },387      dateOperatorIsNotOn: {388        value: {389          normalProviderType: SIMPLE_VALUE_PROVIDER,390          supportAskForValue: true391        },392        field: {393          normalProviderType: LIST_VALUE_PROVIDER394        }395        // Unique type can work already but we set it hidden in UI just right now.396        // ,397        // unique: {398        //   normalProviderType: LIST_VALUE_PROVIDER,399        //   supportAskForValue: true,400        //   filterCodedValueIfPossible: true401        // }402      },403      dateOperatorIsIn: {404        value: {405          normalProviderType: DATE_IS_IN_VALUE_PROVIDER,406          supportAskForValue: true407        }408      },409      dateOperatorIsNotIn: {410        value: {411          normalProviderType: DATE_IS_IN_VALUE_PROVIDER,412          supportAskForValue: true413        }414      },415      dateOperatorIsBefore: {416        value: {417          normalProviderType: SIMPLE_VALUE_PROVIDER,418          supportAskForValue: true419        },420        field: {421          normalProviderType: LIST_VALUE_PROVIDER422        }423      },424      dateOperatorIsAfter: {425        value: {426          normalProviderType: SIMPLE_VALUE_PROVIDER,427          supportAskForValue: true428        },429        field: {430          normalProviderType: LIST_VALUE_PROVIDER431        }432      },433      dateOperatorIsOnOrBefore: {434        value: {435          normalProviderType: SIMPLE_VALUE_PROVIDER,436          supportAskForValue: true437        },438        field: {439          normalProviderType: LIST_VALUE_PROVIDER440        }441      },442      dateOperatorIsOnOrAfter: {443        value: {444          normalProviderType: SIMPLE_VALUE_PROVIDER,445          supportAskForValue: true446        },447        field: {448          normalProviderType: LIST_VALUE_PROVIDER449        }450      },451      dateOperatorInTheLast: {452        value: {453          normalProviderType: NUMBER_LIST_VALUE_PROVIDER,454          supportAskForValue: true455        }456      },457      dateOperatorNotInTheLast: {458        value: {459          normalProviderType: NUMBER_LIST_VALUE_PROVIDER,460          supportAskForValue: true461        }462      },463      dateOperatorIsBetween: {464        value: {465          normalProviderType: TWO_DATES_VALUE_PROVIDER,466          supportAskForValue: true467        }468      },469      dateOperatorIsNotBetween: {470        value: {471          normalProviderType: TWO_DATES_VALUE_PROVIDER,472          supportAskForValue: true473        }474      },475      dateOperatorIsBlank: {476        value: {477          normalProviderType: BLANK_VALUE_PROVIDER478        }479      },480      dateOperatorIsNotBlank: {481        value: {482          normalProviderType: BLANK_VALUE_PROVIDER483        }484      }485    };486    var clazz = declare([], {487      nls: null,488      layerInfo: null,//jimu/LayerInfos/LayerInfo, maybe null489      popupInfo: null,//webmap popupInfo, maybe null490      //options:491      url: null,//required492      layerDefinition: null,//required493      featureLayerId: null,//required494      constructor: function(options){495        //{url,layerDefinition}496        lang.mixin(this, options);497        this.nls = window.jimuNls.filterBuilder;498        var layerInfosObj = LayerInfos.getInstanceSync();499        if(this.featureLayerId){500          this.layerInfo = layerInfosObj.getLayerOrTableInfoById(this.featureLayerId);501          if(this.layerInfo){502            this.popupInfo = this.layerInfo.getPopupInfo();503          }504        }505      },506      getSupportedValueTypes: function(fieldName, operator){507        var valueTypes = [];//["value","field","unique"]508        var operatorInfo = relationship[operator];509        if(operatorInfo){510          // var version = parseFloat(this.layerDefinition.currentVersion);511          if(operatorInfo.value){512            valueTypes.push("value");513          }514          if(operatorInfo.field){515            var fieldNames = this._getSameShortTypeFieldNames(fieldName);516            if(fieldNames.length > 0){517              valueTypes.push("field");518            }519          }520          if(operatorInfo.unique){521            if(this.url){522              if(!this._isStreamServer(this.url)){523                // if(version >= 10.1){524                valueTypes.push("unique");525                // }526              }527            }528          }529          if(operatorInfo.multiple){530            if(this.url){531              if(!this._isStreamServer(this.url)){532                // if(version >= 10.1){  //version, for query params533                valueTypes.push("multiple");534                // }535              }536            }537          }538          // if(operatorInfo.values){   //hide values in UI539          //   valueTypes.push("values");540          // }541          if(operatorInfo.uniquePredefined){542            if(this.url){543              if(!this._isStreamServer(this.url)){544                // if(version >= 10.1){545                valueTypes.push("uniquePredefined");546                // }547              }548            }549          }550          if(operatorInfo.multiplePredefined){551            if(this.url){552              if(!this._isStreamServer(this.url)){553                // if(version >= 10.1){554                valueTypes.push("multiplePredefined");555                // }556              }557            }558          }559        }560        return valueTypes;561      },562      _isStreamServer: function(url){563        url = url || "";564        url = url.replace(/\/*$/g, '');565        var reg = /\/StreamServer$/gi;566        return reg.test(url);567      },568      _getSameShortTypeFieldNames: function(fieldName){569        var fieldNames = [];570        var info = this._getFieldInfo(this.layerDefinition, fieldName);571        var shortType = clazz.getShortTypeByEsriType(info.type);572        array.forEach(this.layerDefinition.fields, lang.hitch(this, function(fieldInfo){573          if(fieldInfo.name !== fieldName){574            if(clazz.getShortTypeByEsriType(fieldInfo.type) === shortType){575              fieldNames.push(fieldInfo.name);576            }577          }578        }));579        return fieldNames;580      },581      _getSameShortTypeFieldNameLabels: function(fieldName){582        var fieldNameLabels = [];583        var info = this._getFieldInfo(this.layerDefinition, fieldName);584        var shortType = clazz.getShortTypeByEsriType(info.type);585        array.forEach(this.layerDefinition.fields, lang.hitch(this, function(fieldInfo){586          if(fieldInfo.name !== fieldName){587            if(clazz.getShortTypeByEsriType(fieldInfo.type) === shortType){588              fieldNameLabels.push({value: fieldInfo.name, label: fieldInfo.alias});589            }590          }591        }));592        return fieldNameLabels;593      },594      getValueProvider: function(partObj, runtime){595        /*{596            "fieldObj": {597              "name": "OBJECTID",598              "label": "OBJECTID",599              "shortType": "number",600              "type": "esriFieldTypeOID"601            },602            "operator": "numberOperatorIs",603            "valueObj": {604              "isValid": true,605              "type": "value",606              "value": 123607            },608            "interactiveObj": "",609            "caseSensitive": false,610            "expr": "OBJECTID = 123"611          }*/612        //partObj.valueObj.type must be set613        //partObj.valueObj.value, partObj.valueObj.value1 and partObj.valueObj.value2 are optional614        var valueProvider = null;615        var operator = partObj.operator;616        var operatorInfo = lang.clone(relationship[operator]);617        if(operatorInfo){618          var valueType = partObj.valueObj.type;619          var fieldName = partObj.fieldObj.name;620          var fieldInfo = this._getFieldInfo(this.layerDefinition, fieldName);621          var valueTypeInfo = operatorInfo[valueType];622          var valueProviderType = valueTypeInfo.normalProviderType;623          var staticValues = null;624          //for codedValues625          var codedValues = jimuUtils.getCodedValueListForCodedValueOrSubTypes(this.layerDefinition, fieldName);626          if(valueType === 'field'){//display with alias and query with name.#14620627            var otherFieldNameLabels = this._getSameShortTypeFieldNameLabels(fieldName);628            if(otherFieldNameLabels.length > 0){629              staticValues = otherFieldNameLabels;630            }631          }else{632            if(codedValues && codedValues.length > 0 && valueTypeInfo.codedValueProviderType){633              valueProviderType = valueTypeInfo.codedValueProviderType;634            }635          }636          var filterCodedValueIfPossible = !!valueTypeInfo.filterCodedValueIfPossible;637          var args = {638            nls: this.nls,639            url: this.url,640            layerDefinition: this.layerDefinition,641            partObj: partObj,642            fieldInfo: fieldInfo,643            codedValues: codedValues,644            staticValues: staticValues,645            layerInfo: this.layerInfo,646            popupInfo: this.popupInfo,647            operatorInfo: operatorInfo,648            filterCodedValueIfPossible: filterCodedValueIfPossible,649            runtime: runtime650          };651          if(valueProviderType === BLANK_VALUE_PROVIDER){652            valueProvider = new BlankValueProvider(args);653          } else if(valueProviderType === SIMPLE_VALUE_PROVIDER){654            valueProvider = new SimpleValueProvider(args);655          }else if(valueProviderType === TWO_NUMBERS_VALUE_PROVIDER){656            valueProvider = new TwoNumbersValueProvider(args);657          }else if(valueProviderType === TWO_DATES_VALUE_PROVIDER){658            valueProvider = new TwoDatesValueProvider(args);659          }else if(valueProviderType === LIST_VALUE_PROVIDER){660            // if(operator === "stringOperatorIs" ||661            //    operator === "stringOperatorIsNot" ||662            //    operator === "numberOperatorIs" ||663            //    operator === "numberOperatorIsNot"){664            //   args.showNullValues = true;665            // }else{666            //   args.showNullValues = false;667            // }668            args.showNullValues = false;669            if(valueType === 'value' || valueType === 'field'){670              // || args.fieldInfo.type === 'esriFieldTypeDate'){671              valueProvider = new ListValueProvider(args);//origin unique provider672            }else{673              args.providerType = valueProviderType;674              args.selectUI = 'dropdown';675              // if(valueType === 'field'){676              //   args.isNumberField = false; //field's name is a string677              // }678              valueProvider = new AdvancedListValueProvider(args);679            }680          }else if(valueProviderType === NUMBER_LIST_VALUE_PROVIDER){681            valueProvider = new NumberListValueProvider(args);682          }else if(valueProviderType === DATE_IS_IN_VALUE_PROVIDER){683            valueProvider = new DateIsInValueProvider(args);684          }685          else if(valueProviderType === ADVANCED_LIST_VALUE_PROVIDER){ //mutiple---setting&runtime686            args.providerType = valueProviderType;687            args.selectUI = 'dropdown';688            valueProvider = new AdvancedListValueProvider(args);689          }690          else if(valueProviderType === UNIQUE_PREDEFINED_VALUE_PROVIDER ||691            valueProviderType === MULTIPLE_PREDEFINED_VALUE_PROVIDER){692            args.providerType = valueProviderType;693            args.selectUI = args.partObj.valueObj ? args.partObj.valueObj.selectUI : null;694            if(runtime){695              valueProvider = new AdvancedListValueProvider(args);696            }else{697              valueProvider = new PredefinedValueProvider(args);698            }699          }700        }701        return valueProvider;702      },703      _getFieldInfo: function(layerDefinition, fieldName){704        var fieldInfos = layerDefinition.fields;705        for(var i = 0;i < fieldInfos.length; i++){706          var fieldInfo = fieldInfos[i];707          if(fieldName === fieldInfo.name){708            return fieldInfo;709          }710        }711        return null;712      }713    });714    clazz.getOperatorInfo = function(operator) {715      var operatorInfo = lang.clone(relationship[operator]);716      return operatorInfo;717    };718    clazz.getOperatorsByShortType = function(shortType, isHosted){719      var operators = [];720      if(shortType === 'string'){721        operators = [722          "stringOperatorIs",723          "stringOperatorIsNot",724          "stringOperatorStartsWith",725          "stringOperatorEndsWith",726          "stringOperatorContains",727          "stringOperatorDoesNotContain",728          "stringOperatorIsAnyOf",729          "stringOperatorIsNoneOf",730          "stringOperatorIsBlank",731          "stringOperatorIsNotBlank"732        ];733      }else if(shortType === 'number'){734        operators = [735          "numberOperatorIs",736          "numberOperatorIsNot",737          "numberOperatorIsAtLeast",738          "numberOperatorIsAtMost",739          "numberOperatorIsLessThan",740          "numberOperatorIsGreaterThan",741          "numberOperatorIsAnyOf",742          "numberOperatorIsNoneOf",743          "numberOperatorIsBetween",744          "numberOperatorIsNotBetween",745          "numberOperatorIsBlank",746          "numberOperatorIsNotBlank"747        ];748      }else if(shortType === 'date'){749        operators = [750          "dateOperatorIsOn",751          "dateOperatorIsNotOn",752          "dateOperatorIsIn",753          "dateOperatorIsNotIn",754          "dateOperatorIsBefore",755          "dateOperatorIsAfter",756          "dateOperatorIsOnOrBefore",757          "dateOperatorIsOnOrAfter",758          "dateOperatorIsBetween",759          "dateOperatorIsNotBetween",760          "dateOperatorIsBlank",761          "dateOperatorIsNotBlank"762        ];763        if(isHosted){764          operators.splice(8,0,"dateOperatorInTheLast","dateOperatorNotInTheLast");765        }766      }767      return operators;768    };769    clazz.getShortTypeByEsriType = function(esriFieldType){770      var shortType = null;771      if(esriFieldType === 'esriFieldTypeString'){772        shortType = 'string';773      }else if(esriFieldType === 'esriFieldTypeDate'){774        shortType = 'date';775      }else{776        var numberTypes = ['esriFieldTypeOID',777                           'esriFieldTypeSmallInteger',778                           'esriFieldTypeInteger',779                           'esriFieldTypeSingle',780                           'esriFieldTypeDouble'];781        if(numberTypes.indexOf(esriFieldType) >= 0){782          shortType = 'number';783        }784      }785      return shortType;786    };787    return clazz;...

provider_analyzer.ts

Source:provider_analyzer.ts

1/**2 * @license3 * Copyright Google Inc. All Rights Reserved.4 *5 * Use of this source code is governed by an MIT-style license that can be6 * found in the LICENSE file at https://angular.io/license7 */8import {CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileDirectiveSummary, CompileNgModuleMetadata, CompileProviderMetadata, CompileQueryMetadata, CompileTokenMetadata, CompileTypeMetadata, tokenName, tokenReference} from './compile_metadata';9import {CompileReflector} from './compile_reflector';10import {Identifiers, createTokenForExternalReference} from './identifiers';11import {ParseError, ParseSourceSpan} from './parse_util';12import {AttrAst, DirectiveAst, ProviderAst, ProviderAstType, QueryMatch, ReferenceAst} from './template_parser/template_ast';13export class ProviderError extends ParseError {14  constructor(message: string, span: ParseSourceSpan) { super(span, message); }15}16export interface QueryWithId {17  meta: CompileQueryMetadata;18  queryId: number;19}20export class ProviderViewContext {21  /**22   * @internal23   */24  viewQueries: Map<any, QueryWithId[]>;25  /**26   * @internal27   */28  viewProviders: Map<any, boolean>;29  errors: ProviderError[] = [];30  constructor(public reflector: CompileReflector, public component: CompileDirectiveMetadata) {31    this.viewQueries = _getViewQueries(component);32    this.viewProviders = new Map<any, boolean>();33    component.viewProviders.forEach((provider) => {34      if (this.viewProviders.get(tokenReference(provider.token)) == null) {35        this.viewProviders.set(tokenReference(provider.token), true);36      }37    });38  }39}40export class ProviderElementContext {41  private _contentQueries: Map<any, QueryWithId[]>;42  private _transformedProviders = new Map<any, ProviderAst>();43  private _seenProviders = new Map<any, boolean>();44  private _allProviders: Map<any, ProviderAst>;45  private _attrs: {[key: string]: string};46  private _queriedTokens = new Map<any, QueryMatch[]>();47  public readonly transformedHasViewContainer: boolean = false;48  constructor(49      public viewContext: ProviderViewContext, private _parent: ProviderElementContext,50      private _isViewRoot: boolean, private _directiveAsts: DirectiveAst[], attrs: AttrAst[],51      refs: ReferenceAst[], isTemplate: boolean, contentQueryStartId: number,52      private _sourceSpan: ParseSourceSpan) {53    this._attrs = {};54    attrs.forEach((attrAst) => this._attrs[attrAst.name] = attrAst.value);55    const directivesMeta = _directiveAsts.map(directiveAst => directiveAst.directive);56    this._allProviders =57        _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, viewContext.errors);58    this._contentQueries = _getContentQueries(contentQueryStartId, directivesMeta);59    Array.from(this._allProviders.values()).forEach((provider) => {60      this._addQueryReadsTo(provider.token, provider.token, this._queriedTokens);61    });62    if (isTemplate) {63      const templateRefId =64          createTokenForExternalReference(this.viewContext.reflector, Identifiers.TemplateRef);65      this._addQueryReadsTo(templateRefId, templateRefId, this._queriedTokens);66    }67    refs.forEach((refAst) => {68      let defaultQueryValue = refAst.value ||69          createTokenForExternalReference(this.viewContext.reflector, Identifiers.ElementRef);70      this._addQueryReadsTo({value: refAst.name}, defaultQueryValue, this._queriedTokens);71    });72    if (this._queriedTokens.get(73            this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef))) {74      this.transformedHasViewContainer = true;75    }76    // create the providers that we know are eager first77    Array.from(this._allProviders.values()).forEach((provider) => {78      const eager = provider.eager || this._queriedTokens.get(tokenReference(provider.token));79      if (eager) {80        this._getOrCreateLocalProvider(provider.providerType, provider.token, true);81      }82    });83  }84  afterElement() {85    // collect lazy providers86    Array.from(this._allProviders.values()).forEach((provider) => {87      this._getOrCreateLocalProvider(provider.providerType, provider.token, false);88    });89  }90  get transformProviders(): ProviderAst[] {91    // Note: Maps keep their insertion order.92    const lazyProviders: ProviderAst[] = [];93    const eagerProviders: ProviderAst[] = [];94    this._transformedProviders.forEach(provider => {95      if (provider.eager) {96        eagerProviders.push(provider);97      } else {98        lazyProviders.push(provider);99      }100    });101    return lazyProviders.concat(eagerProviders);102  }103  get transformedDirectiveAsts(): DirectiveAst[] {104    const sortedProviderTypes = this.transformProviders.map(provider => provider.token.identifier);105    const sortedDirectives = this._directiveAsts.slice();106    sortedDirectives.sort(107        (dir1, dir2) => sortedProviderTypes.indexOf(dir1.directive.type) -108            sortedProviderTypes.indexOf(dir2.directive.type));109    return sortedDirectives;110  }111  get queryMatches(): QueryMatch[] {112    const allMatches: QueryMatch[] = [];113    this._queriedTokens.forEach((matches: QueryMatch[]) => { allMatches.push(...matches); });114    return allMatches;115  }116  private _addQueryReadsTo(117      token: CompileTokenMetadata, defaultValue: CompileTokenMetadata,118      queryReadTokens: Map<any, QueryMatch[]>) {119    this._getQueriesFor(token).forEach((query) => {120      const queryValue = query.meta.read || defaultValue;121      const tokenRef = tokenReference(queryValue);122      let queryMatches = queryReadTokens.get(tokenRef);123      if (!queryMatches) {124        queryMatches = [];125        queryReadTokens.set(tokenRef, queryMatches);126      }127      queryMatches.push({queryId: query.queryId, value: queryValue});128    });129  }130  private _getQueriesFor(token: CompileTokenMetadata): QueryWithId[] {131    const result: QueryWithId[] = [];132    let currentEl: ProviderElementContext = this;133    let distance = 0;134    let queries: QueryWithId[]|undefined;135    while (currentEl !== null) {136      queries = currentEl._contentQueries.get(tokenReference(token));137      if (queries) {138        result.push(...queries.filter((query) => query.meta.descendants || distance <= 1));139      }140      if (currentEl._directiveAsts.length > 0) {141        distance++;142      }143      currentEl = currentEl._parent;144    }145    queries = this.viewContext.viewQueries.get(tokenReference(token));146    if (queries) {147      result.push(...queries);148    }149    return result;150  }151  private _getOrCreateLocalProvider(152      requestingProviderType: ProviderAstType, token: CompileTokenMetadata,153      eager: boolean): ProviderAst|null {154    const resolvedProvider = this._allProviders.get(tokenReference(token));155    if (!resolvedProvider || ((requestingProviderType === ProviderAstType.Directive ||156                               requestingProviderType === ProviderAstType.PublicService) &&157                              resolvedProvider.providerType === ProviderAstType.PrivateService) ||158        ((requestingProviderType === ProviderAstType.PrivateService ||159          requestingProviderType === ProviderAstType.PublicService) &&160         resolvedProvider.providerType === ProviderAstType.Builtin)) {161      return null;162    }163    let transformedProviderAst = this._transformedProviders.get(tokenReference(token));164    if (transformedProviderAst) {165      return transformedProviderAst;166    }167    if (this._seenProviders.get(tokenReference(token)) != null) {168      this.viewContext.errors.push(new ProviderError(169          `Cannot instantiate cyclic dependency! ${tokenName(token)}`, this._sourceSpan));170      return null;171    }172    this._seenProviders.set(tokenReference(token), true);173    const transformedProviders = resolvedProvider.providers.map((provider) => {174      let transformedUseValue = provider.useValue;175      let transformedUseExisting = provider.useExisting !;176      let transformedDeps: CompileDiDependencyMetadata[] = undefined !;177      if (provider.useExisting != null) {178        const existingDiDep = this._getDependency(179            resolvedProvider.providerType, {token: provider.useExisting}, eager) !;180        if (existingDiDep.token != null) {181          transformedUseExisting = existingDiDep.token;182        } else {183          transformedUseExisting = null !;184          transformedUseValue = existingDiDep.value;185        }186      } else if (provider.useFactory) {187        const deps = provider.deps || provider.useFactory.diDeps;188        transformedDeps =189            deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager) !);190      } else if (provider.useClass) {191        const deps = provider.deps || provider.useClass.diDeps;192        transformedDeps =193            deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep, eager) !);194      }195      return _transformProvider(provider, {196        useExisting: transformedUseExisting,197        useValue: transformedUseValue,198        deps: transformedDeps199      });200    });201    transformedProviderAst =202        _transformProviderAst(resolvedProvider, {eager: eager, providers: transformedProviders});203    this._transformedProviders.set(tokenReference(token), transformedProviderAst);204    return transformedProviderAst;205  }206  private _getLocalDependency(207      requestingProviderType: ProviderAstType, dep: CompileDiDependencyMetadata,208      eager: boolean = false): CompileDiDependencyMetadata|null {209    if (dep.isAttribute) {210      const attrValue = this._attrs[dep.token !.value];211      return {isValue: true, value: attrValue == null ? null : attrValue};212    }213    if (dep.token != null) {214      // access builtints215      if ((requestingProviderType === ProviderAstType.Directive ||216           requestingProviderType === ProviderAstType.Component)) {217        if (tokenReference(dep.token) ===218                this.viewContext.reflector.resolveExternalReference(Identifiers.Renderer) ||219            tokenReference(dep.token) ===220                this.viewContext.reflector.resolveExternalReference(Identifiers.ElementRef) ||221            tokenReference(dep.token) ===222                this.viewContext.reflector.resolveExternalReference(223                    Identifiers.ChangeDetectorRef) ||224            tokenReference(dep.token) ===225                this.viewContext.reflector.resolveExternalReference(Identifiers.TemplateRef)) {226          return dep;227        }228        if (tokenReference(dep.token) ===229            this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {230          (this as{transformedHasViewContainer: boolean}).transformedHasViewContainer = true;231        }232      }233      // access the injector234      if (tokenReference(dep.token) ===235          this.viewContext.reflector.resolveExternalReference(Identifiers.Injector)) {236        return dep;237      }238      // access providers239      if (this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager) != null) {240        return dep;241      }242    }243    return null;244  }245  private _getDependency(246      requestingProviderType: ProviderAstType, dep: CompileDiDependencyMetadata,247      eager: boolean = false): CompileDiDependencyMetadata|null {248    let currElement: ProviderElementContext = this;249    let currEager: boolean = eager;250    let result: CompileDiDependencyMetadata|null = null;251    if (!dep.isSkipSelf) {252      result = this._getLocalDependency(requestingProviderType, dep, eager);253    }254    if (dep.isSelf) {255      if (!result && dep.isOptional) {256        result = {isValue: true, value: null};257      }258    } else {259      // check parent elements260      while (!result && currElement._parent) {261        const prevElement = currElement;262        currElement = currElement._parent;263        if (prevElement._isViewRoot) {264          currEager = false;265        }266        result = currElement._getLocalDependency(ProviderAstType.PublicService, dep, currEager);267      }268      // check @Host restriction269      if (!result) {270        if (!dep.isHost || this.viewContext.component.isHost ||271            this.viewContext.component.type.reference === tokenReference(dep.token !) ||272            this.viewContext.viewProviders.get(tokenReference(dep.token !)) != null) {273          result = dep;274        } else {275          result = dep.isOptional ? result = {isValue: true, value: null} : null;276        }277      }278    }279    if (!result) {280      this.viewContext.errors.push(281          new ProviderError(`No provider for ${tokenName(dep.token!)}`, this._sourceSpan));282    }283    return result;284  }285}286export class NgModuleProviderAnalyzer {287  private _transformedProviders = new Map<any, ProviderAst>();288  private _seenProviders = new Map<any, boolean>();289  private _allProviders: Map<any, ProviderAst>;290  private _errors: ProviderError[] = [];291  constructor(292      private reflector: CompileReflector, ngModule: CompileNgModuleMetadata,293      extraProviders: CompileProviderMetadata[], sourceSpan: ParseSourceSpan) {294    this._allProviders = new Map<any, ProviderAst>();295    ngModule.transitiveModule.modules.forEach((ngModuleType: CompileTypeMetadata) => {296      const ngModuleProvider = {token: {identifier: ngModuleType}, useClass: ngModuleType};297      _resolveProviders(298          [ngModuleProvider], ProviderAstType.PublicService, true, sourceSpan, this._errors,299          this._allProviders);300    });301    _resolveProviders(302        ngModule.transitiveModule.providers.map(entry => entry.provider).concat(extraProviders),303        ProviderAstType.PublicService, false, sourceSpan, this._errors, this._allProviders);304  }305  parse(): ProviderAst[] {306    Array.from(this._allProviders.values()).forEach((provider) => {307      this._getOrCreateLocalProvider(provider.token, provider.eager);308    });309    if (this._errors.length > 0) {310      const errorString = this._errors.join('\n');311      throw new Error(`Provider parse errors:\n${errorString}`);312    }313    // Note: Maps keep their insertion order.314    const lazyProviders: ProviderAst[] = [];315    const eagerProviders: ProviderAst[] = [];316    this._transformedProviders.forEach(provider => {317      if (provider.eager) {318        eagerProviders.push(provider);319      } else {320        lazyProviders.push(provider);321      }322    });323    return lazyProviders.concat(eagerProviders);324  }325  private _getOrCreateLocalProvider(token: CompileTokenMetadata, eager: boolean): ProviderAst|null {326    const resolvedProvider = this._allProviders.get(tokenReference(token));327    if (!resolvedProvider) {328      return null;329    }330    let transformedProviderAst = this._transformedProviders.get(tokenReference(token));331    if (transformedProviderAst) {332      return transformedProviderAst;333    }334    if (this._seenProviders.get(tokenReference(token)) != null) {335      this._errors.push(new ProviderError(336          `Cannot instantiate cyclic dependency! ${tokenName(token)}`,337          resolvedProvider.sourceSpan));338      return null;339    }340    this._seenProviders.set(tokenReference(token), true);341    const transformedProviders = resolvedProvider.providers.map((provider) => {342      let transformedUseValue = provider.useValue;343      let transformedUseExisting = provider.useExisting !;344      let transformedDeps: CompileDiDependencyMetadata[] = undefined !;345      if (provider.useExisting != null) {346        const existingDiDep =347            this._getDependency({token: provider.useExisting}, eager, resolvedProvider.sourceSpan);348        if (existingDiDep.token != null) {349          transformedUseExisting = existingDiDep.token;350        } else {351          transformedUseExisting = null !;352          transformedUseValue = existingDiDep.value;353        }354      } else if (provider.useFactory) {355        const deps = provider.deps || provider.useFactory.diDeps;356        transformedDeps =357            deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));358      } else if (provider.useClass) {359        const deps = provider.deps || provider.useClass.diDeps;360        transformedDeps =361            deps.map((dep) => this._getDependency(dep, eager, resolvedProvider.sourceSpan));362      }363      return _transformProvider(provider, {364        useExisting: transformedUseExisting,365        useValue: transformedUseValue,366        deps: transformedDeps367      });368    });369    transformedProviderAst =370        _transformProviderAst(resolvedProvider, {eager: eager, providers: transformedProviders});371    this._transformedProviders.set(tokenReference(token), transformedProviderAst);372    return transformedProviderAst;373  }374  private _getDependency(375      dep: CompileDiDependencyMetadata, eager: boolean = false,376      requestorSourceSpan: ParseSourceSpan): CompileDiDependencyMetadata {377    let foundLocal = false;378    if (!dep.isSkipSelf && dep.token != null) {379      // access the injector380      if (tokenReference(dep.token) ===381              this.reflector.resolveExternalReference(Identifiers.Injector) ||382          tokenReference(dep.token) ===383              this.reflector.resolveExternalReference(Identifiers.ComponentFactoryResolver)) {384        foundLocal = true;385        // access providers386      } else if (this._getOrCreateLocalProvider(dep.token, eager) != null) {387        foundLocal = true;388      }389    }390    let result: CompileDiDependencyMetadata = dep;391    if (dep.isSelf && !foundLocal) {392      if (dep.isOptional) {393        result = {isValue: true, value: null};394      } else {395        this._errors.push(396            new ProviderError(`No provider for ${tokenName(dep.token!)}`, requestorSourceSpan));397      }398    }399    return result;400  }401}402function _transformProvider(403    provider: CompileProviderMetadata,404    {useExisting, useValue, deps}:405        {useExisting: CompileTokenMetadata, useValue: any, deps: CompileDiDependencyMetadata[]}) {406  return {407    token: provider.token,408    useClass: provider.useClass,409    useExisting: useExisting,410    useFactory: provider.useFactory,411    useValue: useValue,412    deps: deps,413    multi: provider.multi414  };415}416function _transformProviderAst(417    provider: ProviderAst,418    {eager, providers}: {eager: boolean, providers: CompileProviderMetadata[]}): ProviderAst {419  return new ProviderAst(420      provider.token, provider.multiProvider, provider.eager || eager, providers,421      provider.providerType, provider.lifecycleHooks, provider.sourceSpan);422}423function _resolveProvidersFromDirectives(424    directives: CompileDirectiveSummary[], sourceSpan: ParseSourceSpan,425    targetErrors: ParseError[]): Map<any, ProviderAst> {426  const providersByToken = new Map<any, ProviderAst>();427  directives.forEach((directive) => {428    const dirProvider:429        CompileProviderMetadata = {token: {identifier: directive.type}, useClass: directive.type};430    _resolveProviders(431        [dirProvider],432        directive.isComponent ? ProviderAstType.Component : ProviderAstType.Directive, true,433        sourceSpan, targetErrors, providersByToken);434  });435  // Note: directives need to be able to overwrite providers of a component!436  const directivesWithComponentFirst =437      directives.filter(dir => dir.isComponent).concat(directives.filter(dir => !dir.isComponent));438  directivesWithComponentFirst.forEach((directive) => {439    _resolveProviders(440        directive.providers, ProviderAstType.PublicService, false, sourceSpan, targetErrors,441        providersByToken);442    _resolveProviders(443        directive.viewProviders, ProviderAstType.PrivateService, false, sourceSpan, targetErrors,444        providersByToken);445  });446  return providersByToken;447}448function _resolveProviders(449    providers: CompileProviderMetadata[], providerType: ProviderAstType, eager: boolean,450    sourceSpan: ParseSourceSpan, targetErrors: ParseError[],451    targetProvidersByToken: Map<any, ProviderAst>) {452  providers.forEach((provider) => {453    let resolvedProvider = targetProvidersByToken.get(tokenReference(provider.token));454    if (resolvedProvider != null && !!resolvedProvider.multiProvider !== !!provider.multi) {455      targetErrors.push(new ProviderError(456          `Mixing multi and non multi provider is not possible for token ${tokenName(resolvedProvider.token)}`,457          sourceSpan));458    }459    if (!resolvedProvider) {460      const lifecycleHooks = provider.token.identifier &&461              (<CompileTypeMetadata>provider.token.identifier).lifecycleHooks ?462          (<CompileTypeMetadata>provider.token.identifier).lifecycleHooks :463          [];464      const isUseValue = !(provider.useClass || provider.useExisting || provider.useFactory);465      resolvedProvider = new ProviderAst(466          provider.token, !!provider.multi, eager || isUseValue, [provider], providerType,467          lifecycleHooks, sourceSpan);468      targetProvidersByToken.set(tokenReference(provider.token), resolvedProvider);469    } else {470      if (!provider.multi) {471        resolvedProvider.providers.length = 0;472      }473      resolvedProvider.providers.push(provider);474    }475  });476}477function _getViewQueries(component: CompileDirectiveMetadata): Map<any, QueryWithId[]> {478  // Note: queries start with id 1 so we can use the number in a Bloom filter!479  let viewQueryId = 1;480  const viewQueries = new Map<any, QueryWithId[]>();481  if (component.viewQueries) {482    component.viewQueries.forEach(483        (query) => _addQueryToTokenMap(viewQueries, {meta: query, queryId: viewQueryId++}));484  }485  return viewQueries;486}487function _getContentQueries(488    contentQueryStartId: number, directives: CompileDirectiveSummary[]): Map<any, QueryWithId[]> {489  let contentQueryId = contentQueryStartId;490  const contentQueries = new Map<any, QueryWithId[]>();491  directives.forEach((directive, directiveIndex) => {492    if (directive.queries) {493      directive.queries.forEach(494          (query) => _addQueryToTokenMap(contentQueries, {meta: query, queryId: contentQueryId++}));495    }496  });497  return contentQueries;498}499function _addQueryToTokenMap(map: Map<any, QueryWithId[]>, query: QueryWithId) {500  query.meta.selectors.forEach((token: CompileTokenMetadata) => {501    let entry = map.get(tokenReference(token));502    if (!entry) {503      entry = [];504      map.set(tokenReference(token), entry);505    }506    entry.push(query);507  });...

provider_compiler.ts

Source:provider_compiler.ts

1/**2 * @license3 * Copyright Google Inc. All Rights Reserved.4 *5 * Use of this source code is governed by an MIT-style license that can be6 * found in the LICENSE file at https://angular.io/license7 */8import {CompileDiDependencyMetadata, CompileEntryComponentMetadata, CompileProviderMetadata, CompileTokenMetadata} from '../compile_metadata';9import {CompileReflector} from '../compile_reflector';10import {DepFlags, NodeFlags} from '../core';11import {Identifiers, createTokenForExternalReference} from '../identifiers';12import {LifecycleHooks} from '../lifecycle_reflector';13import * as o from '../output/output_ast';14import {convertValueToOutputAst} from '../output/value_util';15import {ProviderAst, ProviderAstType} from '../template_parser/template_ast';16import {OutputContext} from '../util';17export function providerDef(ctx: OutputContext, providerAst: ProviderAst): {18  providerExpr: o.Expression,19  flags: NodeFlags,20  depsExpr: o.Expression,21  tokenExpr: o.Expression22} {23  let flags = NodeFlags.None;24  if (!providerAst.eager) {25    flags |= NodeFlags.LazyProvider;26  }27  if (providerAst.providerType === ProviderAstType.PrivateService) {28    flags |= NodeFlags.PrivateProvider;29  }30  providerAst.lifecycleHooks.forEach((lifecycleHook) => {31    // for regular providers, we only support ngOnDestroy32    if (lifecycleHook === LifecycleHooks.OnDestroy ||33        providerAst.providerType === ProviderAstType.Directive ||34        providerAst.providerType === ProviderAstType.Component) {35      flags |= lifecycleHookToNodeFlag(lifecycleHook);36    }37  });38  const {providerExpr, flags: providerFlags, depsExpr} = providerAst.multiProvider ?39      multiProviderDef(ctx, flags, providerAst.providers) :40      singleProviderDef(ctx, flags, providerAst.providerType, providerAst.providers[0]);41  return {42    providerExpr,43    flags: providerFlags, depsExpr,44    tokenExpr: tokenExpr(ctx, providerAst.token),45  };46}47function multiProviderDef(48    ctx: OutputContext, flags: NodeFlags, providers: CompileProviderMetadata[]):49    {providerExpr: o.Expression, flags: NodeFlags, depsExpr: o.Expression} {50  const allDepDefs: o.Expression[] = [];51  const allParams: o.FnParam[] = [];52  const exprs = providers.map((provider, providerIndex) => {53    let expr: o.Expression;54    if (provider.useClass) {55      const depExprs = convertDeps(providerIndex, provider.deps || provider.useClass.diDeps);56      expr = ctx.importExpr(provider.useClass.reference).instantiate(depExprs);57    } else if (provider.useFactory) {58      const depExprs = convertDeps(providerIndex, provider.deps || provider.useFactory.diDeps);59      expr = ctx.importExpr(provider.useFactory.reference).callFn(depExprs);60    } else if (provider.useExisting) {61      const depExprs = convertDeps(providerIndex, [{token: provider.useExisting}]);62      expr = depExprs[0];63    } else {64      expr = convertValueToOutputAst(ctx, provider.useValue);65    }66    return expr;67  });68  const providerExpr =69      o.fn(allParams, [new o.ReturnStatement(o.literalArr(exprs))], o.INFERRED_TYPE);70  return {71    providerExpr,72    flags: flags | NodeFlags.TypeFactoryProvider,73    depsExpr: o.literalArr(allDepDefs)74  };75  function convertDeps(providerIndex: number, deps: CompileDiDependencyMetadata[]) {76    return deps.map((dep, depIndex) => {77      const paramName = `p${providerIndex}_${depIndex}`;78      allParams.push(new o.FnParam(paramName, o.DYNAMIC_TYPE));79      allDepDefs.push(depDef(ctx, dep));80      return o.variable(paramName);81    });82  }83}84function singleProviderDef(85    ctx: OutputContext, flags: NodeFlags, providerType: ProviderAstType,86    providerMeta: CompileProviderMetadata):87    {providerExpr: o.Expression, flags: NodeFlags, depsExpr: o.Expression} {88  let providerExpr: o.Expression;89  let deps: CompileDiDependencyMetadata[];90  if (providerType === ProviderAstType.Directive || providerType === ProviderAstType.Component) {91    providerExpr = ctx.importExpr(providerMeta.useClass !.reference);92    flags |= NodeFlags.TypeDirective;93    deps = providerMeta.deps || providerMeta.useClass !.diDeps;94  } else {95    if (providerMeta.useClass) {96      providerExpr = ctx.importExpr(providerMeta.useClass.reference);97      flags |= NodeFlags.TypeClassProvider;98      deps = providerMeta.deps || providerMeta.useClass.diDeps;99    } else if (providerMeta.useFactory) {100      providerExpr = ctx.importExpr(providerMeta.useFactory.reference);101      flags |= NodeFlags.TypeFactoryProvider;102      deps = providerMeta.deps || providerMeta.useFactory.diDeps;103    } else if (providerMeta.useExisting) {104      providerExpr = o.NULL_EXPR;105      flags |= NodeFlags.TypeUseExistingProvider;106      deps = [{token: providerMeta.useExisting}];107    } else {108      providerExpr = convertValueToOutputAst(ctx, providerMeta.useValue);109      flags |= NodeFlags.TypeValueProvider;110      deps = [];111    }112  }113  const depsExpr = o.literalArr(deps.map(dep => depDef(ctx, dep)));114  return {providerExpr, flags, depsExpr};115}116function tokenExpr(ctx: OutputContext, tokenMeta: CompileTokenMetadata): o.Expression {117  return tokenMeta.identifier ? ctx.importExpr(tokenMeta.identifier.reference) :118                                o.literal(tokenMeta.value);119}120export function depDef(ctx: OutputContext, dep: CompileDiDependencyMetadata): o.Expression {121  // Note: the following fields have already been normalized out by provider_analyzer:122  // - isAttribute, isSelf, isHost123  const expr = dep.isValue ? convertValueToOutputAst(ctx, dep.value) : tokenExpr(ctx, dep.token !);124  let flags = DepFlags.None;125  if (dep.isSkipSelf) {126    flags |= DepFlags.SkipSelf;127  }128  if (dep.isOptional) {129    flags |= DepFlags.Optional;130  }131  if (dep.isValue) {132    flags |= DepFlags.Value;133  }134  return flags === DepFlags.None ? expr : o.literalArr([o.literal(flags), expr]);135}136export function lifecycleHookToNodeFlag(lifecycleHook: LifecycleHooks): NodeFlags {137  let nodeFlag = NodeFlags.None;138  switch (lifecycleHook) {139    case LifecycleHooks.AfterContentChecked:140      nodeFlag = NodeFlags.AfterContentChecked;141      break;142    case LifecycleHooks.AfterContentInit:143      nodeFlag = NodeFlags.AfterContentInit;144      break;145    case LifecycleHooks.AfterViewChecked:146      nodeFlag = NodeFlags.AfterViewChecked;147      break;148    case LifecycleHooks.AfterViewInit:149      nodeFlag = NodeFlags.AfterViewInit;150      break;151    case LifecycleHooks.DoCheck:152      nodeFlag = NodeFlags.DoCheck;153      break;154    case LifecycleHooks.OnChanges:155      nodeFlag = NodeFlags.OnChanges;156      break;157    case LifecycleHooks.OnDestroy:158      nodeFlag = NodeFlags.OnDestroy;159      break;160    case LifecycleHooks.OnInit:161      nodeFlag = NodeFlags.OnInit;162      break;163  }164  return nodeFlag;165}166export function componentFactoryResolverProviderDef(167    reflector: CompileReflector, ctx: OutputContext, flags: NodeFlags,168    entryComponents: CompileEntryComponentMetadata[]): {169  providerExpr: o.Expression,170  flags: NodeFlags,171  depsExpr: o.Expression,172  tokenExpr: o.Expression173} {174  const entryComponentFactories =175      entryComponents.map((entryComponent) => ctx.importExpr(entryComponent.componentFactory));176  const token = createTokenForExternalReference(reflector, Identifiers.ComponentFactoryResolver);177  const classMeta = {178    diDeps: [179      {isValue: true, value: o.literalArr(entryComponentFactories)},180      {token: token, isSkipSelf: true, isOptional: true},181      {token: createTokenForExternalReference(reflector, Identifiers.NgModuleRef)},182    ],183    lifecycleHooks: [],184    reference: reflector.resolveExternalReference(Identifiers.CodegenComponentFactoryResolver)185  };186  const {providerExpr, flags: providerFlags, depsExpr} =187      singleProviderDef(ctx, flags, ProviderAstType.PrivateService, {188        token,189        multi: false,190        useClass: classMeta,191      });192  return {providerExpr, flags: providerFlags, depsExpr, tokenExpr: tokenExpr(ctx, token)};...

provider.js

Source:provider.js

1var chai = require('chai');2var assert = chai.assert;3var net = require('net');4var Eth = require('../packages/web3-eth');5var Shh = require('../packages/web3-shh');6var Net = require('../packages/web3-net');7var Web3 = require('../packages/web3');8var tests = [{9    providerParams: ['http://localhost:8545'],10    providerType: 'HttpProvider',11    package: Web312},{13    providerParams: ['HTTP://localhost:8545'],14    providerType: 'HttpProvider',15    package: Web316},{17    providerParams: ['ws://localhost:8546'],18    providerType: 'WebsocketProvider',19    package: Web320},{21    providerParams: ['WS://localhost:8546'],22    providerType: 'WebsocketProvider',23    package: Web324},{25    providerParams: ['wss://user1:passw0rd@localhost:8546'],26    providerType: 'WebsocketProvider',27    package: Web328},{29    providerParams: ['/.ethereum/my/path/geth.ipc', net],30    providerType: 'IpcProvider',31    package: Web332},{33    providerParams: ['\\\\.\\pipe\\geth.ipc', net],34    providerType: 'IpcProvider',35    package: Web336},{37    providerParams: ['://hello.com:1234'],38    package: Web3,39    error: true40},41    {42        providerParams: ['http://localhost:8545'],43        providerType: 'HttpProvider',44        package: Net45    },{46        providerParams: ['HTTP://localhost:8545'],47        providerType: 'HttpProvider',48        package: Net49    },{50        providerParams: ['ws://localhost:8546'],51        providerType: 'WebsocketProvider',52        package: Net53    },{54        providerParams: ['WS://localhost:8546'],55        providerType: 'WebsocketProvider',56        package: Net57    },{58        providerParams: ['/.ethereum/my/path/geth.ipc', net],59        providerType: 'IpcProvider',60        package: Net61    },{62        providerParams: ['\\\\.\\pipe\\geth.ipc', net],63        providerType: 'IpcProvider',64        package: Net65    },{66        providerParams: ['://hello.com:1234'],67        package: Net,68        error: true69    },70    {71        providerParams: ['http://localhost:8545'],72        providerType: 'HttpProvider',73        package: Shh74    },{75        providerParams: ['HTTP://localhost:8545'],76        providerType: 'HttpProvider',77        package: Shh78    },{79        providerParams: ['ws://localhost:8546'],80        providerType: 'WebsocketProvider',81        package: Shh82    },{83        providerParams: ['WS://localhost:8546'],84        providerType: 'WebsocketProvider',85        package: Shh86    },{87        providerParams: ['/.ethereum/my/path/geth.ipc', net],88        providerType: 'IpcProvider',89        package: Shh90    },{91        providerParams: ['\\\\.\\pipe\\geth.ipc', net],92        providerType: 'IpcProvider',93        package: Shh94    },{95        providerParams: ['://hello.com:1234'],96        package: Shh,97        error: true98    },99    {100        providerParams: ['http://localhost:8545'],101        providerType: 'HttpProvider',102        package: Eth103    },{104        providerParams: ['HTTP://localhost:8545'],105        providerType: 'HttpProvider',106        package: Eth107    },{108        providerParams: ['ws://localhost:8546'],109        providerType: 'WebsocketProvider',110        package: Eth111    },{112        providerParams: ['WS://localhost:8546'],113        providerType: 'WebsocketProvider',114        package: Eth115    },{116        providerParams: ['/.ethereum/my/path/geth.ipc', net],117        providerType: 'IpcProvider',118        package: Eth119    },{120        providerParams: ['\\\\.\\pipe\\geth.ipc', net],121        providerType: 'IpcProvider',122        package: Eth123    },{124        providerParams: ['://hello.com:1234'],125        package: Eth,126        error: true127    }];128describe('web3', function () {129    describe('automatic provider selection', function () {130        tests.forEach(function (test, index) {131            if(!test.error) {132                it('initiates on package level', function () {133                    var pkg = new test.package(test.providerParams[0], test.providerParams[1]);134                    assert.equal(pkg.currentProvider.constructor.name, test.providerType);135                });136                it('initiates using setProvider', function () {137                    var pkg = new test.package();138                    assert.equal(pkg.currentProvider, null);139                    pkg.setProvider.apply(pkg, test.providerParams);140                    assert.equal(pkg.currentProvider.constructor.name, test.providerType);141                });142            } else {143                it('can\'t autodetect the provider', function () {144                    assert.throws(function(){ new test.package(test.providerParams[0]); });145                });146                it('can\'t autodetect the provider when using setProvider', function () {147                    var pkg = new test.package();148                    assert.throws(function(){ pkg.setProvider(test.providerParams[0]); });149                });150            }151        });152    });...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.