d5-api-initializer 0.0.2-alpha.0

package/publish/d5-api-initializer.legacy-esm.js

@@ -0,0 +1,801 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/classes/ApiHttpResponse.ts
+var ApiHttpResponse = class {
+  constructor(jsWapiHttpResponse) {
+    __publicField(this, "_jsWapiHttpResponse");
+    this._jsWapiHttpResponse = jsWapiHttpResponse;
+  }
+  get statusCode() {
+    return this._jsWapiHttpResponse.getStatusCode();
+  }
+  get body() {
+    return this._jsWapiHttpResponse.getBody();
+  }
+  get bodyAsStream() {
+    return this._jsWapiHttpResponse.getBodyAsInputStream();
+  }
+  getHeader(name) {
+    return this._jsWapiHttpResponse.getHeader(name);
+  }
+  isSuccessful() {
+    return this._jsWapiHttpResponse.isSuccessful();
+  }
+};
+
+// src/classes/ApiHttpRequest.ts
+var ApiHttpRequest = class {
+  constructor(jsWapiHttp) {
+    __publicField(this, "_jsWapiHttp");
+    this._jsWapiHttp = jsWapiHttp;
+  }
+  set headers(headers) {
+    for (const headersKey in headers) {
+      this._jsWapiHttp = this._jsWapiHttp.setHeader(headersKey, JSON.stringify(headers[headersKey]));
+    }
+  }
+  set timeout(milliseconds) {
+    this._jsWapiHttp = this._jsWapiHttp.setTimeout(milliseconds);
+  }
+  setHeader(name, value) {
+    this._jsWapiHttp = this._jsWapiHttp.setHeader(name, "".concat(value));
+    return this;
+  }
+  setHeaders(headers) {
+    for (const headersKey in headers) {
+      this._jsWapiHttp = this._jsWapiHttp.setHeader(headersKey, "".concat(headers[headersKey]));
+    }
+    return this;
+  }
+  setTimeout(milliseconds) {
+    this._jsWapiHttp = this._jsWapiHttp.setTimeout(milliseconds);
+    return this;
+  }
+  GET(callback) {
+    return this._jsWapiHttp.GET(this._getWrappedCallback(callback));
+  }
+  POST(requestBody, callback) {
+    return this._jsWapiHttp.POST(JSON.stringify(requestBody), this._getWrappedCallback(callback));
+  }
+  PUT(requestBody, callback) {
+    return this._jsWapiHttp.PUT(JSON.stringify(requestBody), this._getWrappedCallback(callback));
+  }
+  PATCH(requestBody, callback) {
+    return this._jsWapiHttp.PATCH(JSON.stringify(requestBody), this._getWrappedCallback(callback));
+  }
+  _getWrappedCallback(callback) {
+    return (res) => {
+      if (callback) {
+        return callback(new ApiHttpResponse(res));
+      }
+    };
+  }
+};
+
+// src/classes/ApiResponse.ts
+var ApiResponse = class {
+  constructor(jsWapiResponse, objectName) {
+    __publicField(this, "_jsWapiResponse");
+    __publicField(this, "_objectName");
+    this._jsWapiResponse = jsWapiResponse;
+    this._objectName = objectName;
+  }
+  get objectName() {
+    return this._objectName;
+  }
+  set response(response) {
+    this.setResponse(response);
+  }
+  getResponse(responseName) {
+    return this._jsWapiResponse.getResponse(responseName || this._objectName);
+  }
+  setResponse(response, fieldsMap) {
+    if (Array.isArray(response)) {
+      const data = !fieldsMap ? response : response.map((row) => {
+        const res = {};
+        for (const externalKey in fieldsMap) {
+          res[fieldsMap[externalKey]] = row[externalKey];
+        }
+        return res;
+      });
+      this._jsWapiResponse.putResponse(this._objectName, data);
+    } else {
+      this._jsWapiResponse.setResponse(response);
+    }
+    return this;
+  }
+  sendHttpResponse(headers, body) {
+    this._jsWapiResponse.sendHttpResponse(headers, body);
+    return this;
+  }
+  sendHttpBody(body) {
+    this._jsWapiResponse.sendHttpResponse({}, body);
+    return this;
+  }
+  getPage() {
+    return this._jsWapiResponse.getPage();
+  }
+  setPage(page) {
+    this._jsWapiResponse.setPage(page);
+    return this;
+  }
+  getPagesPredict() {
+    return this._jsWapiResponse.getPagesPredict();
+  }
+  setPagesPredict(pagesPredict) {
+    this._jsWapiResponse.setPagesPredict(pagesPredict);
+    return this;
+  }
+};
+
+// src/classes/ApiInvoker.ts
+var ApiInvoker = class {
+  constructor(jsWapiInvoker, objectName) {
+    __publicField(this, "_jsWapiInvoker");
+    __publicField(this, "_objectName");
+    this._jsWapiInvoker = jsWapiInvoker;
+    this._objectName = objectName;
+  }
+  /* ----------------------------Accessors---------------------------- */
+  get objectName() {
+    return this._objectName;
+  }
+  set filters(filters) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setFilters(filters);
+  }
+  set params(params) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setParams(params);
+  }
+  set rowsPerPage(amount) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setRowsPerPage(amount);
+  }
+  set page(number) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setPage(number);
+  }
+  set pagesPredict(amount) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setPagesPredict(amount);
+  }
+  set request(request) {
+    if (Array.isArray(request)) {
+      this._jsWapiInvoker = this._jsWapiInvoker.putRequest(this._objectName, request);
+    } else {
+      this._jsWapiInvoker = this._jsWapiInvoker.setRequest(request);
+    }
+  }
+  get request() {
+    return this._jsWapiInvoker.getRequest();
+  }
+  set columns(columns) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setColumns(columns);
+  }
+  set sorts(sorts) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setSorts(sorts);
+  }
+  set aggregatedColumns(aggregatedColumns) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setAggregatedColumns(aggregatedColumns);
+  }
+  set nestedColumns(nestedColumns) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setNestedColumns(nestedColumns);
+  }
+  /* -----------------------------Setters----------------------------- */
+  setHierarchy(parentColumn, requestKind) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setHierarchy(parentColumn, requestKind);
+    return this;
+  }
+  setFilters(filters) {
+    this.filters = filters;
+    return this;
+  }
+  setParams(params) {
+    this.params = params;
+    return this;
+  }
+  setPage(number) {
+    this.page = number;
+    return this;
+  }
+  setRowsPerPage(amount) {
+    this.rowsPerPage = amount;
+    return this;
+  }
+  setPagesPredict(amount) {
+    this.pagesPredict = amount;
+    return this;
+  }
+  setRequest(request) {
+    this.request = request;
+    return this;
+  }
+  getRequest(requestName) {
+    return this._jsWapiInvoker.getRequest(requestName);
+  }
+  setSrcRequest(srcRequest) {
+    this._jsWapiInvoker = this._jsWapiInvoker.setSrcRequest(srcRequest);
+    return this;
+  }
+  getSrcRequest() {
+    throw new Error("not implemented");
+    return this._jsWapiInvoker.getSrcRequest();
+  }
+  setColumns(columns) {
+    this.columns = columns;
+    return this;
+  }
+  setAggregatedColumns(aggregatedColumns) {
+    this.aggregatedColumns = aggregatedColumns;
+    return this;
+  }
+  setNestedColumns(nestedColumns) {
+    this.nestedColumns = nestedColumns;
+    return this;
+  }
+  setSorts(sorts) {
+    this.sorts = sorts;
+    return this;
+  }
+  setFirstRows(firstRows) {
+    this._jsWapiInvoker.setFirstRows(firstRows);
+    return this;
+  }
+  setOperRightCheck(check) {
+    this._jsWapiInvoker.setOperRightCheck(check);
+    return this;
+  }
+  getFirstRows() {
+    return this._jsWapiInvoker.getFirstRows();
+  }
+  /* -----------------------------Adders------------------------------ */
+  addColumns(columns) {
+    this._jsWapiInvoker = this._jsWapiInvoker.addColumns(columns);
+    return this;
+  }
+  addAggregatedColumns(aggregatedColumns) {
+    this._jsWapiInvoker = this._jsWapiInvoker.putAggregatedColumns(aggregatedColumns);
+    return this;
+  }
+  addNestedColumns(nestedColumns) {
+    this._jsWapiInvoker = this._jsWapiInvoker.putNestedColumns(nestedColumns);
+    return this;
+  }
+  addSorts(sorts) {
+    this._jsWapiInvoker = this._jsWapiInvoker.addSorts(sorts);
+    return this;
+  }
+  /* ------------------------------Other------------------------------ */
+  invoke() {
+    return new ApiResponse(this._jsWapiInvoker.invoke(), this._objectName);
+  }
+};
+
+// src/classes/UserMessages.ts
+function formatMessage(text, args = []) {
+  let str = text;
+  for (let v in args) {
+    str = str.replace(`{${v}}`, args[v] == null ? "" : args[v]);
+  }
+  return str;
+}
+var UserMessages = class {
+  constructor() {
+    __publicField(this, "_messages", {});
+    __publicField(this, "_lang", "ua" /* ua */);
+  }
+  appendDictionary(newDictionary) {
+    if (Array.isArray(newDictionary) || !newDictionary || typeof newDictionary !== "object")
+      return;
+    for (const key in newDictionary) {
+      if (!this._messages.hasOwnProperty(key)) {
+        this._messages[key] = {};
+      }
+      this._messages[key] = Object.assign(this._messages[key], newDictionary[key]);
+    }
+  }
+  format(msgKey, params) {
+    const msg = this._messages[this._lang]?.[msgKey] ?? msgKey;
+    return formatMessage(msg, params);
+  }
+  set lang(value) {
+    this._lang = value;
+  }
+};
+var UserMessages_default = new UserMessages();
+
+// src/classes/ApiObjectCollectionIterator.ts
+var ApiObjectCollectionIterator = class {
+  constructor({ invoker }) {
+    __publicField(this, "_invoker");
+    this._invoker = invoker;
+  }
+  get objectName() {
+    return this._invoker.objectName;
+  }
+  /* -----------------------------Setters----------------------------- */
+  setColumns(columns) {
+    this._invoker.setColumns(columns);
+    return this;
+  }
+  setFilters(filters) {
+    this._invoker.setFilters(filters);
+    return this;
+  }
+  setSorts(sorts) {
+    this._invoker.setSorts(sorts);
+    return this;
+  }
+  /* -----------------------------Adders------------------------------ */
+  addSorts(sorts) {
+    this._invoker.addSorts(sorts);
+    return this;
+  }
+  addColumns(columns) {
+    this._invoker.addColumns(columns);
+    return this;
+  }
+  /* ------------------------------Other------------------------------ */
+  *invoke() {
+    let data = null, pageCount = 1;
+    let lastPage = false;
+    const rowsPerPage = 100;
+    while (!lastPage) {
+      this._invoker.page = pageCount;
+      this._invoker.rowsPerPage = rowsPerPage;
+      data = new ApiResponse(this._invoker.invoke(), this.objectName).getResponse();
+      pageCount++;
+      if (Array.isArray(data)) {
+        for (let i = 0; i < data.length; i++) {
+          yield data[i];
+        }
+      }
+      lastPage = data.length < rowsPerPage;
+    }
+  }
+};
+
+// src/classes/ApiCore.ts
+var ApiCore = class {
+  constructor({ http, request }) {
+    __publicField(this, "httpSender");
+    __publicField(this, "_request");
+    this.httpSender = http;
+    this._request = request;
+  }
+  /**
+   * Переводит и форматирует строку из словаря переводов согласно текущего языка приложения.
+   * @param msgKey
+   * @param params
+   *
+   * @example
+   *  {
+   *    ...
+   *    "myKey": 'some text with {0}'
+   *    ...
+   *  }
+   *  t('myKey', ['placeholder text']) // 'some text with placeholder text'
+   */
+  t(msgKey, params) {
+    UserMessages_default.lang = this._request.lang || "ua" /* ua */;
+    return UserMessages_default.format(msgKey, params);
+  }
+  newHttpRequest(url) {
+    return new ApiHttpRequest(this.httpSender.newJSWapiHttp(url));
+  }
+  newApiInvoker(objectName, operName) {
+    return new ApiInvoker(this._request.newJSWapiInvoker(objectName, operName), objectName);
+  }
+  newApiObjectCollectionIterator(objectName) {
+    return new ApiObjectCollectionIterator({
+      invoker: this.newApiInvoker(objectName, "List")
+    });
+  }
+  newApiException(message, code) {
+    if (code) {
+      return new JSWapiException(code.toString(), message);
+    }
+    return new JSWapiException(message);
+  }
+  /*
+  * Will be implemented later
+  *
+  newApiJoinInvoker(alias: string, request: ApiRequest | ApiInvoker): ApiJoinInvoker {
+      if (request instanceof ApiRequest) {
+          return new ApiJoinInvoker(this._jsWapiRequest.newJSWapiJoinInvoker(alias, request._jsWapiRequest));
+      } else if (request instanceof ApiInvoker) {
+          return new ApiJoinInvoker(this._jsWapiRequest.newJSWapiJoinInvoker(alias, request._jsWapiInvoker));
+      }
+  }
+   */
+};
+
+// src/classes/ApiRequest.ts
+var ApiRequest = class {
+  constructor(jsWapiRequest, objectName) {
+    __publicField(this, "_jsWapiRequest");
+    __publicField(this, "_objectName");
+    this._jsWapiRequest = jsWapiRequest;
+    this._objectName = objectName;
+  }
+  /* ----------------------------Accessors---------------------------- */
+  get objectName() {
+    return this._objectName;
+  }
+  get columns() {
+    return this._jsWapiRequest.getColumns();
+  }
+  get aggregatedColumns() {
+    return this._jsWapiRequest.getAggregatedColumns();
+  }
+  get nestedColumns() {
+    return this._jsWapiRequest.getNestedColumns();
+  }
+  get filters() {
+    return this._jsWapiRequest.getFilters();
+  }
+  get params() {
+    return this._jsWapiRequest.getParams();
+  }
+  get request() {
+    return this._jsWapiRequest.getRequest(this._objectName);
+  }
+  get userId() {
+    return this._jsWapiRequest.getUserId();
+  }
+  get page() {
+    return this._jsWapiRequest.getPage();
+  }
+  get rowsPerPage() {
+    return this._jsWapiRequest.getRowsPerPage();
+  }
+  get sorts() {
+    return this._jsWapiRequest.getSorts();
+  }
+  get lang() {
+    return this._jsWapiRequest.getLanguage();
+  }
+  set columns(columns) {
+    this._jsWapiRequest = this._jsWapiRequest.setColumns(columns);
+  }
+  set aggregatedColumns(columns) {
+    this._jsWapiRequest = this._jsWapiRequest.setAggregatedColumns(columns);
+  }
+  set nestedColumns(columns) {
+    this._jsWapiRequest = this._jsWapiRequest.setNestedColumns(columns);
+  }
+  set filters(filters) {
+    this._jsWapiRequest = this._jsWapiRequest.setFilters(filters);
+  }
+  set params(params) {
+    this._jsWapiRequest = this._jsWapiRequest.setParams(params);
+  }
+  set sorts(sorts) {
+    this._jsWapiRequest = this._jsWapiRequest.setSorts(sorts);
+  }
+  set page(number) {
+    this._jsWapiRequest = this._jsWapiRequest.setPage(number);
+  }
+  set rowsPerPage(amount) {
+    this._jsWapiRequest = this._jsWapiRequest.setRowsPerPage(amount);
+  }
+  /* -----------------------------Getters----------------------------- */
+  getFilter(filterName) {
+    return this._jsWapiRequest.getFilter(filterName);
+  }
+  /**
+   * Вернуть значение фильтра типа "равно".
+   * Возможные варианты:
+   *     "поле": "значение"
+   *     "поле": {"=": "значение"}
+   *     "поле": ["значение"]
+   *     "поле": {"=": [123]}
+   * Это чтобы не парсить каждый раз все эти варианты.
+   *
+   * Работает только для условия "равно", для други возвращает null!!!!
+   */
+  getFilterValue(fieldName) {
+    return this._jsWapiRequest.getFilterEqualOneValue(fieldName);
+  }
+  getParam(paramName) {
+    return this._jsWapiRequest.getParam(paramName);
+  }
+  getExcelFileAsJson(fileRequestId) {
+    return this._jsWapiRequest.getExcelFileAsJson(fileRequestId);
+  }
+  getFileAsString(fileRequestId) {
+    return this._jsWapiRequest.getFileAsString(fileRequestId);
+  }
+  getFilesListAsString(filesRequestIds) {
+    return this._jsWapiRequest.getMultiFileAsString(...this._getWithStringifiedElements(filesRequestIds));
+  }
+  getExcelFilesListAsJson(filesRequestIds) {
+    return this._jsWapiRequest.getMultiExcelFileAsJson(...this._getWithStringifiedElements(filesRequestIds));
+  }
+  getRequest(requestName) {
+    return this._jsWapiRequest.getRequest(requestName);
+  }
+  /* -----------------------------Setters----------------------------- */
+  setHierarchy(parentColumn, requestKind) {
+    this._jsWapiRequest = this._jsWapiRequest.setHierarchy(parentColumn, requestKind);
+    return this;
+  }
+  setColumns(columns) {
+    this.columns = columns;
+    return this;
+  }
+  setNestedColumns(nestedColumns) {
+    this.nestedColumns = nestedColumns;
+    return this;
+  }
+  setAggregatedColumns(aggregatedColumns) {
+    this.aggregatedColumns = aggregatedColumns;
+    return this;
+  }
+  setFilters(filters) {
+    this.filters = filters;
+    return this;
+  }
+  setSorts(sorts) {
+    this.sorts = sorts;
+    return this;
+  }
+  setParams(params) {
+    this.params = params;
+    return this;
+  }
+  setPage(number) {
+    this.page = number;
+    return this;
+  }
+  setRowsPerPage(amount) {
+    this.rowsPerPage = amount;
+    return this;
+  }
+  setRequest(request) {
+    if (Array.isArray(request)) {
+      this._jsWapiRequest = this._jsWapiRequest.putRequest(this._objectName, request);
+    } else {
+      this._jsWapiRequest = this._jsWapiRequest.setRequest(request);
+    }
+    return this;
+  }
+  setFirstRows(firstRows) {
+    this._jsWapiRequest.setFirstRows(firstRows);
+    return this;
+  }
+  getFirstRows() {
+    return this._jsWapiRequest.getFirstRows();
+  }
+  addSorts(sorts) {
+    this._jsWapiRequest = this._jsWapiRequest.addSorts(sorts);
+    return this;
+  }
+  addColumns(columns) {
+    this._jsWapiRequest = this._jsWapiRequest.addColumns(columns);
+    return this;
+  }
+  addAggregatedColumns(columns) {
+    this._jsWapiRequest = this._jsWapiRequest.putAggregatedColumns(columns);
+    return this;
+  }
+  /**
+   * @link http://d5.develop.erp-director.com/userscript-docs/docs/server_scripts/api-request/api-request#addnestedcolumnscolumns
+   * @example
+   * apiRequest.addNestedColumns({
+   *     'AuthorsNested': {
+   *         'Columns': ['ID', 'Name']
+   *     }
+   * });
+   */
+  addNestedColumns(columns) {
+    this._jsWapiRequest = this._jsWapiRequest.putNestedColumns(columns);
+    return this;
+  }
+  addFilters(filters) {
+    this._jsWapiRequest = this._jsWapiRequest.putFilters(filters);
+    return this;
+  }
+  addParams(params) {
+    for (const name in params) {
+      this._jsWapiRequest = this._jsWapiRequest.putParam(name, params[name]);
+    }
+    return this;
+  }
+  /* ----------------------------Removers----------------------------- */
+  removeSorts(sortsNames) {
+    this._jsWapiRequest = this._jsWapiRequest.removeSorts(sortsNames);
+    return this;
+  }
+  removeColumns(columnsNames) {
+    this._jsWapiRequest = this._jsWapiRequest.removeColumns(columnsNames);
+    return this;
+  }
+  removeAggregatedColumns(aggregatedColumnsNames) {
+    this._jsWapiRequest = this._jsWapiRequest.removeAggregatedColumns(aggregatedColumnsNames);
+    return this;
+  }
+  removeNestedColumns(nestedColumnsNames) {
+    this._jsWapiRequest = this._jsWapiRequest.removeNestedColumns(nestedColumnsNames);
+    return this;
+  }
+  removeParams(paramsNames) {
+    this._jsWapiRequest = this._jsWapiRequest.removeParams(paramsNames);
+    return this;
+  }
+  removeFilters(filtersNames) {
+    this._jsWapiRequest = this._jsWapiRequest.removeFilters(filtersNames);
+    return this;
+  }
+  /* ------------------------------Other------------------------------ */
+  hasFilter(filterName) {
+    return this._jsWapiRequest.isFilterExists(filterName);
+  }
+  invoke() {
+    return new ApiResponse(this._jsWapiRequest.invoke(), this._objectName);
+  }
+  newJSWapiInvoker(objectName, operName) {
+    return this._jsWapiRequest.newJSWapiInvoker(objectName, operName);
+  }
+  newApiInvoker(objectName, operName) {
+    return new ApiInvoker(this.newJSWapiInvoker(objectName, operName), objectName);
+  }
+  /**
+   * Переводит и форматирует строку из словаря переводов согласно текущего языка приложения.
+   * @param msgKey
+   * @param params
+   *
+   * @example
+   *  {
+   *    ...
+   *    "myKey": 'some text with {0}'
+   *    ...
+   *  }
+   *  t('myKey', ['placeholder text']) // 'some text with placeholder text'
+   */
+  t(msgKey, params) {
+    UserMessages_default.lang = this.lang || "ua" /* ua */;
+    return UserMessages_default.format(msgKey, params);
+  }
+  /* -------------------------Support methods------------------------- */
+  _getWithStringifiedElements(array) {
+    return array.map((element) => element.toString());
+  }
+};
+
+// src/classes/ApiObjectInitializer.ts
+var ApiInitializer = class {
+  constructor(settings, operations, options) {
+    __publicField(this, "_api");
+    __publicField(this, "_operations");
+    this._api = jsWapi;
+    const throwError = (msg) => {
+      throw new Error(msg);
+    };
+    if (typeof settings === "string") {
+      if (!operations)
+        throwError('The second argument "operations" is required');
+      this._operations = operations;
+      this.internalCreate(settings);
+      options?.translations && this.initTranslation(options.translations);
+      return;
+    }
+    const { objectName, operations: opers, translations } = settings;
+    if (!opers)
+      throwError('Property "operations" in the settings is required');
+    this._operations = opers;
+    this.internalCreate(objectName);
+    translations && this.initTranslation(translations);
+  }
+  _initOperations(objectName) {
+    for (const operationName in this._operations) {
+      this.putOperation(operationName, objectName);
+    }
+  }
+  /**
+   * Инициализация словаря переводов.
+   * @param translations
+   * @example Пример строки перевода
+   * { ...
+   *  "ru": {"key": 'some text {0} {1}'}
+   *   ...
+   * }
+   *
+   *  core.t('key', ['test1', 'test2']); // 'some text test1 test2'
+   */
+  initTranslation(translations) {
+    UserMessages_default.appendDictionary(translations);
+  }
+};
+var ApiObjectInitializer = class extends ApiInitializer {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "jsWapiObject");
+  }
+  internalCreate(objectName) {
+    this._api.putJSWapiObject(objectName, (jsWapiObject) => {
+      this.jsWapiObject = jsWapiObject;
+      this._initOperations(objectName);
+    });
+  }
+  putOperation(operationName, objectName) {
+    this.jsWapiObject.putJSWapiOper(operationName, (jsWapiRequest, jsWapiResponse) => {
+      const request = new ApiRequest(jsWapiRequest, objectName);
+      return this._operations[operationName](
+        new ApiCore({ http: this.jsWapiObject, request }),
+        request,
+        new ApiResponse(jsWapiResponse, objectName)
+      );
+    });
+  }
+};
+
+// src/classes/EngineInitializer.ts
+var EngineInitializer = class {
+  constructor(arg1, arg2) {
+    __publicField(this, "engine");
+    __publicField(this, "_operations");
+    let operations = arg1.operations || arg1;
+    let translations = arg1.translations || arg2?.translations;
+    const throwError = (msg) => {
+      throw new Error(msg);
+    };
+    if (!operations)
+      throwError('Property "operations" in the settings is required');
+    this._operations = operations;
+    this.internalCreate();
+    translations && this.initTranslation(translations);
+  }
+  internalCreate() {
+    jsWapi.setJSWapiEngine((engine) => {
+      this.engine = engine;
+      for (const operationName in this._operations) {
+        this.putOperation(operationName);
+      }
+    });
+  }
+  putOperation(operationName) {
+    this.engine.putJSWapiOper(operationName, (jsWapiRequest, jsWapiResponse) => {
+      const request = new ApiRequest(jsWapiRequest, this.engine.getName());
+      const apiCore = new ApiCore({ http: this.engine, request });
+      return this._operations[operationName](
+        apiCore,
+        request,
+        new ApiResponse(jsWapiResponse, this.engine.getName()),
+        {
+          parameters: this.engine.getExternalSystemParameters(),
+          objectName: this.engine.getName(),
+          externalObject: this.engine.getExternalName(),
+          externalFieldsMap: this.engine.getExternalObjectFields()
+        }
+      );
+    });
+  }
+  /**
+   * Инициализация словаря переводов.
+   * @param translations
+   * @example Пример строки перевода
+   * { ...
+   *  "ru": {"key": 'some text {0} {1}'}
+   *   ...
+   * }
+   *
+   *  core.t('key', ['test1', 'test2']); // 'some text test1 test2'
+   */
+  initTranslation(translations) {
+    UserMessages_default.appendDictionary(translations);
+  }
+  call({ apiCore, apiRequest, apiResponse, operation, meta }) {
+    return this._operations[operation](
+      apiCore,
+      apiRequest,
+      apiResponse,
+      meta
+    );
+  }
+};
+export {
+  ApiObjectInitializer,
+  EngineInitializer
+};