Method description

src/wsdl/elements.ts:213–325

(definitions: DefinitionsElement, xmlns?: IXmlNs)

  public $lookupTypes?: any[];

  public description(definitions: DefinitionsElement, xmlns?: IXmlNs) {
    let element = {};
    let name = this.$name;

    // Check minOccurs / maxOccurs attributes to see if this element is a list
    // These are default values for an element
    let minOccurs = 1;
    let maxOccurs = 1;

    if (this.$maxOccurs === 'unbounded') {
      maxOccurs = Infinity;
    } else if (this.$maxOccurs) {
      maxOccurs = parseInt(this.$maxOccurs, 10);
    }

    if (this.$minOccurs) {
      //eslint-disable-next-line @typescript-eslint/no-unused-vars
      minOccurs = parseInt(this.$minOccurs, 10);
    }

    const isMany = maxOccurs > 1;

    if (isMany && name) {
      name += '[]';
    }

    if (xmlns && xmlns[TNS_PREFIX]) {
      this.$targetNamespace = xmlns[TNS_PREFIX];
    }
    let type: any = this.$type || this.$ref;
    if (type) {
      type = splitQName(type);
      const typeName: string = type.name;
      const useSchemaXmlns = !!findNs(type.prefix, this.definitionsXmlns, definitions.xmlns) || !!findNs(this.targetNSAlias, this.definitionsXmlns, definitions.xmlns) || this.forceUseSchemaXmlns;
      const ns = findNs(type.prefix, xmlns, this.xmlns, useSchemaXmlns ? this.schemaXmlns : undefined, this.definitionsXmlns, definitions.xmlns);
      const schema = definitions.schemas[ns];
      const typeElement = schema && (this.$type ? schema.complexTypes[typeName] || schema.types[typeName] : schema.elements[typeName]);
      const typeStorage = this.$type ? definitions.descriptions.types : definitions.descriptions.elements;

      // Use namespace + typeName as cache key to avoid conflicts between schemas
      const cacheKey = ns ? `${ns}::${typeName}` : typeName;

      if (ns && definitions.schemas[ns]) {
        xmlns = definitions.schemas[ns].xmlns;
      }

      if (typeElement && !(typeName in Primitives)) {
        if (!(cacheKey in typeStorage)) {
          let elem: any = {};
          typeStorage[cacheKey] = elem;

          if (isMany && 'maxOccurs' in typeElement) {
            typeElement.maxOccurs = this.$maxOccurs;
          }
          if (Boolean(this.$minOccurs) && 'minOccurs' in typeElement) {
            typeElement.minOccurs = this.$minOccurs;
          }