(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (factory((global.KintoneConfigHelper = {})));
}(this, (function (exports) { 'use strict';

  var ALL_FIELD_TYPES = [
      "SINGLE_LINE_TEXT",
      "MULTI_LINE_TEXT",
      "RICH_TEXT",
      "NUMBER",
      "CALC",
      "RADIO_BUTTON",
      "CHECK_BOX",
      "MULTI_SELECT",
      "DROP_DOWN",
      "DATE",
      "TIME",
      "DATETIME",
      "FILE",
      "LINK",
      "USER_SELECT",
      "ORGANIZATION_SELECT",
      "GROUP_SELECT",
      "REFERENCE_TABLE",
      "SPACER",
      "GROUP",
      "SUBTABLE",
      "RECORD_NUMBER",
      "CREATOR",
      "CREATED_TIME",
      "MODIFIER",
      "UPDATED_TIME"
  ];
  function createKintoneClient(kintone) {
      function fetchFormInfoByFields() {
          var url = kintone.api.url("/k/v1/preview/app/form/fields", true);
          var body = {
              app: kintone.app.getId()
          };
          return kintone.api(url, "GET", body).then(function (resp) {
              return resp.properties;
          });
      }
      function fetchFormInfoByLayout() {
          var url = kintone.api.url("/k/v1/preview/app/form/layout", true);
          var body = {
              app: kintone.app.getId()
          };
          return kintone.api(url, "GET", body).then(function (resp) {
              return resp.layout;
          });
      }
      return {
          fetchFormInfoByFields: fetchFormInfoByFields,
          fetchFormInfoByLayout: fetchFormInfoByLayout
      };
  }

  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation. All rights reserved.
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at http://www.apache.org/licenses/LICENSE-2.0

  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  MERCHANTABLITY OR NON-INFRINGEMENT.

  See the Apache Version 2.0 License for specific language governing permissions
  and limitations under the License.
  ***************************************************************************** */

  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      };
      return __assign.apply(this, arguments);
  };

  function __rest(s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
              t[p[i]] = s[p[i]];
      return t;
  }

  var NOT_EXIST_MESSAGE = "Either the specified field type does not exist, or this method cannot respond the specified field type.";
  var NOT_MATCH_MESSAGE = "Specify either characters or an array of characters for the getAllFields parameter.";

  function createGetFields(kintoneClient, Promise_) {
      var Promise = Promise_;
      var fetchFormInfoByFields = kintoneClient.fetchFormInfoByFields, fetchFormInfoByLayout = kintoneClient.fetchFormInfoByLayout;
      function removeUnnecessaryProperties(field) {
          var _ = field.size, rest = __rest(field, ["size"]);
          return rest;
      }
      function getFieldInfo(layoutFields) {
          return layoutFields
              .filter(function (layout) { return layout.type !== "LABEL" && layout.type !== "HR"; })
              .map(function (field) { return removeUnnecessaryProperties(field); });
      }
      function modifiedLayoutResp(layoutList) {
          return layoutList.reduce(function (acc, layout) {
              switch (layout.type) {
                  case "ROW":
                      return acc.concat(getFieldInfo(layout.fields));
                  case "GROUP":
                      return acc.concat([
                          { type: layout.type, code: layout.code }
                      ], layout.layout
                          .map(function (childLayout) { return getFieldInfo(childLayout.fields); })
                          .reduce(function (acc, cur) { return acc.concat(cur); }, []));
                  case "SUBTABLE":
                      var layoutFieldsIncludeSubtableCode = layout.fields.map(function (layoutField) { return (__assign({}, layoutField, { subtableCode: layout.code })); });
                      return acc.concat([
                          { type: layout.type, code: layout.code }
                      ], getFieldInfo(layoutFieldsIncludeSubtableCode));
              }
          }, []);
      }
      function getLabeledFields(fieldsResp) {
          return Object.keys(fieldsResp).reduce(function (acc, key) {
              var _a;
              var field = fieldsResp[key];
              if (field.type === "SUBTABLE") {
                  return __assign({}, acc, getLabeledFields(field.fields));
              }
              return field.label ? __assign({}, acc, (_a = {}, _a[field.code] = field.label, _a)) : acc;
          }, {});
      }
      function addLabel(layoutFieldList, fieldsResp) {
          var labeledFields = getLabeledFields(fieldsResp);
          return layoutFieldList.map(function (layoutField) {
              return labeledFields[layoutField.code]
                  ? __assign({}, layoutField, { label: labeledFields[layoutField.code] }) : layoutField;
          });
      }
      function getLookupFieldKeys(fieldsResp) {
          return Object.keys(fieldsResp).filter(function (key) { return typeof fieldsResp[key].lookup !== "undefined"; });
      }
      function filterLookupField(layoutFieldList, fieldsResp) {
          var lookupFieldKeys = getLookupFieldKeys(fieldsResp);
          if (lookupFieldKeys.length === 0)
              ;
          return layoutFieldList.filter(function (layoutField) {
              return !lookupFieldKeys.some(function (key) { return fieldsResp[key].code === layoutField.code; });
          });
      }
      function flattenFieldsForSubtable(fieldsResp) {
          return Object.keys(fieldsResp).reduce(function (fields, key) {
              var _a, _b;
              if (fieldsResp[key].type === "SUBTABLE") {
                  return __assign({}, fields, (_a = {}, _a[key] = fieldsResp[key], _a), fieldsResp[key].fields);
              }
              return __assign({}, fields, (_b = {}, _b[key] = fieldsResp[key], _b));
          }, {});
      }
      function fetchAllFields(selectFieldTypes) {
          return Promise.all([fetchFormInfoByFields(), fetchFormInfoByLayout()]).then(function (_a) {
              var fieldsResp = _a[0], layoutResp = _a[1];
              var fieldList = addLabel(filterLookupField(modifiedLayoutResp(layoutResp), flattenFieldsForSubtable(fieldsResp)), fieldsResp);
              return selectFieldTypes
                  ? fieldList.filter(function (field) { return selectFieldTypes.indexOf(field.type) !== -1; })
                  : fieldList;
          });
      }
      function validateFieldType(fieldType) {
          return ALL_FIELD_TYPES.some(function (type) { return type === fieldType; });
      }
      function validateGetAllFieldsArgument(fieldType) {
          if (typeof fieldType === "string") {
              return validateFieldType(fieldType) ? null : NOT_EXIST_MESSAGE;
          }
          if (Array.isArray(fieldType)) {
              return fieldType.every(validateFieldType) ? null : NOT_EXIST_MESSAGE;
          }
          return NOT_MATCH_MESSAGE;
      }
      function getFields(selectFieldType) {
          if (typeof selectFieldType === "undefined") {
              return fetchAllFields();
          }
          var error = validateGetAllFieldsArgument(selectFieldType);
          if (error) {
              return Promise.reject(new Error(error));
          }
          return fetchAllFields(Array.isArray(selectFieldType) ? selectFieldType : [selectFieldType]);
      }
      return getFields;
  }

  var kintone = window.kintone;
  var kintoneClient = createKintoneClient(kintone);
  var getFields = createGetFields(kintoneClient, kintone.Promise);

  exports.getFields = getFields;

  Object.defineProperty(exports, '__esModule', { value: true });

})));