How to use

toJsArray

function

in

Array

_getEntity(e) {
    let enty = new Entity({
      surface: e.getSurface(),
      label: e.getLabel().name(),
      fineLabel: e.getFineLabel(),
      morphemes: JVM.toJsArray(e, (x) => this._getMorph(x)),
      originalLabel: getOrUndefined(e.getOriginalLabel())
    });
    enty.reference = e;

    return enty;
  }

_getRole(e) {
    let edge = new RoleEdge({
      predicate: this._getWord(e.getPredicate()),
      argument: this._getWord(e.getArgument()),
      label: e.getLabel().name(),
      modifiers: JVM.toJsArray(e.getModifiers(), (x) => this._getWord(x)),
      originalLabel: getOrUndefined(e.getOriginalLabel())
    });
    edge.reference = e;

    return edge;
  }

_getCorefGroup(c) {
    let coref = new CoreferenceGroup(
      JVM.toJsArray(c, (e) => {
        let referenced = this._getEntity(e);
        return this.entities.find((enty) => enty.equals(referenced));
      })
    );

    coref.reference = c;
    return coref;
  }

/**
   * 전체 값의 목록을 불러옵니다.
   * @param clsName 불러올 클래스
   * @returns {Array} 전체 값 목록
   */
  static getAllOf(...clsName){
    return JVM.toJsArray(JVM.koalaClassOf(...clsName).values());
  }

/**
   * 사전에 등재되어 있는지 확인하고, 사전에 없는단어만 반환합니다.
   * @param {boolean} onlySystemDic 시스템 사전에서만 검색할지 결정합니다.
   * @param {DicEntry} word {'surface':형태소, 'tag':품사}들. (가변인자)
   * @return {DicEntry[]} 사전에 없는 단어들
   */
  async getNotExists(onlySystemDic, ...word) {
    let zipped = word.map((pair) => JVM.pair(pair.surface, pair.tag.reference));
    return JVM.toJsArray(await this._api.getNotExistsPromise(onlySystemDic, ...zipped), readDicEntry);
  }

/**
   * KoalaNLP가 구현한 문장분리기를 사용하여, 문단을 문장으로 분리합니다. (Synchronous)
   * @param {Word[]} paragraph 분석할 문단. (품사표기가 되어있어야 합니다)
   * @returns {Sentence} 분리된 문장
   */
  static sentencesSync(paragraph) {
    let sent = [];
    for (let word of paragraph) {
      sent.push(word.getReference());
    }

    return JVM.toJsArray(JVM.koalaClassOf('proc', 'SentenceSplitter').INSTANCE.sentences(sent), (x) => new Sentence(x));
  }

/**
   * 문단(들)을 품사분석합니다. (Synchronous)
   * @param {...(string|string[])} text 분석할 문단들. 텍스트와 string 리스트 혼용 가능. (가변인자)
   * @returns {Sentence[]} 분석된 결과 (Flattened list)
   */
  tagSync(...text) {
    let result = [];
    for (let paragraph of text) {
      if (Array.isArray(paragraph)) {
        result.push(...this.tagSync(...paragraph));
      } else {
        if (paragraph.trim().length == 0)
          continue;

        result.push(...JVM.toJsArray(this._api.tag(paragraph), (x) => new Sentence(x)));
      }
    }
    return result;
  }

/**
   * 사용자 사전에 등재된 모든 항목을 가져옵니다.
   * @return {DicEntry[]} {'surface':형태소, 'tag':품사}의 list
   */
  async getItems() {
    return JVM.toJsArray(await this._api.getItemsPromise(), readDicEntry, true);
  }

/**
   * 문단(들)을 분석합니다. (Synchronous)
   *
   * @param {...(string|Sentence|string[]|Sentence[])} text 분석할 문단(들).
   * 각 인자는 텍스트(str), 문장 객체(Sentence), 텍스트의 리스트, 문장 객체의 리스트 혼용 가능 (가변인자)
   * @returns {Sentence[]} 분석된 결과 (Flattened list)
   */
  analyzeSync(...text) {
    let result = [];
    for (let paragraph of text) {
      if (paragraph instanceof Sentence) {
        result.push(new Sentence(this._api.analyze(paragraph.reference)));
      } else if (Array.isArray(paragraph)) {
        result.push(...this.analyzeSync(...paragraph));
      } else {
        if (paragraph.trim().length == 0)
          continue;

        result.push(...JVM.toJsArray(this._api.analyze(paragraph), (x) => new Sentence(x)));
      }
    }

    return result;
  }

_reconSyntaxTree(jtree) {
    if (!isDefined(jtree))
      return undefined;

    let term;
    let nonTerms;

    if (isDefined(jtree.getTerminal())) {
      term = this._getWord(jtree.getTerminal());
    }

    if (jtree.hasNonTerminals()) {
      nonTerms = JVM.toJsArray(jtree, (x) => this._reconSyntaxTree(x));
    }

    let tree = new SyntaxTree({
      label: jtree.getLabel().name(),
      terminal: term,
      children: nonTerms,
      originalLabel: getOrUndefined(jtree.getOriginalLabel())
    });
    tree.reference = jtree;

    return tree;
  }

/**
   * 문단(들)을 분석합니다. (Asynchronous)
   *
   * @param {...(string|Sentence|string[]|Sentence[])} text 분석할 문단(들).
   * 각 인자는 텍스트(str), 문장 객체(Sentence), 텍스트의 리스트, 문장 객체의 리스트 혼용 가능 (가변인자)
   * @returns {Sentence[]} 분석된 결과 (Flattened list)
   */
  async analyze(...text) {
    let result = [];
    for (let paragraph of text) {
      let promiseResult;
      if (paragraph instanceof Sentence) {
        promiseResult = await this._api.analyzePromise(paragraph.reference);
        result.push(new Sentence(promiseResult));
      } else if (Array.isArray(paragraph)) {
        promiseResult = await this.analyze(...paragraph);
        result.push(...promiseResult);
      } else {
        if (paragraph.trim().length == 0)
          continue;

        promiseResult = await this._api.analyzePromise(paragraph);
        result.push(...JVM.toJsArray(promiseResult, (x) => new Sentence(x)));
      }
    }

    return result;
  }

/**
   * KoalaNLP가 구현한 문장분리기를 사용하여, 문단을 문장으로 분리합니다. (Asynchronous)
   * @param {Word[]} paragraph 분석할 문단. (품사표기가 되어있어야 합니다)
   * @returns {Sentence} 분리된 문장
   */
  static async sentences(paragraph) {
    let sent = [];
    for (let word of paragraph) {
      sent.push(word.getReference());
    }

    let promiseResult = await JVM.koalaClassOf('proc', 'SentenceSplitter').INSTANCE.sentencesPromise(sent);
    return JVM.toJsArray(promiseResult, (x) => new Sentence(x));
  }

/**
   * 문단을 문장으로 분리합니다. (Asynchronous)
   * @param {...!string} text 분석할 문단들 (가변인자)
   * @returns {string[]} 분리한 문장들.
   */
  async sentences(...text) {
    let result = [];
    for (let paragraph of text) {
      if (Array.isArray(paragraph)) {
        result.push(...await this.sentences(...paragraph));
      } else {
        if (paragraph.trim().length == 0)
          continue;

        let promiseResult = await this._api.sentencesPromise(paragraph);
        result.push(...JVM.toJsArray(promiseResult));
      }
    }
    return result;
  }

/**
   * 문단(들)을 품사분석합니다. (Asynchronous)
   * @param {...(string|string[])} text 분석할 문단들. 텍스트와 string 리스트 혼용 가능. (가변인자)
   * @returns {Sentence[]} 분석된 결과 (Flattened list)
   */
  async tag(...text) {
    let result = [];
    for (let paragraph of text) {
      let promiseResult;
      if (Array.isArray(paragraph)) {
        promiseResult = await this.tag(...paragraph);
        result.push(...promiseResult);
      } else {
        if (paragraph.trim().length == 0)
          continue;

        promiseResult = await this._api.tagPromise(paragraph);
        result.push(...JVM.toJsArray(promiseResult, (x) => new Sentence(x)));
      }
    }
    return result;
  }

/**
   * 문단을 문장으로 분리합니다. (Synchronous)
   * @param {...!string} text 분석할 문단들 (가변인자)
   * @returns {string[]} 분리한 문장들.
   */
  sentencesSync(...text) {
    let result = [];
    for (let paragraph of text) {
      if (Array.isArray(paragraph)) {
        result.push(...this.sentencesSync(...paragraph));
      } else {
        if (paragraph.trim().length == 0)
          continue;

        result.push(...JVM.toJsArray(this._api.sentences(paragraph)));
      }
    }
    return result;
  }