@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/ts/ts/fable_modules/Fable.SimpleHttp.3.5.0/Http.fs.js

@@ -0,0 +1,142 @@
+import { fromContinuations } from '../../../node_modules/@fable-org/fable-library-js/Async.js';
+import { singleton } from '../../../node_modules/@fable-org/fable-library-js/AsyncBuilder.js';
+import { HttpRequest, HttpMethod_GET, BodyContent_Empty, HttpResponse, ResponseContent_Text, ResponseContent_ArrayBuffer, ResponseContent_Blob, ResponseContent_Unknown } from './Types.fs.js';
+import { empty, ofArray as ofArray$1, isEmpty, head, tail } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { empty as empty$1, ofArray } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { comparePrimitives, getEnumerator, disposeSafe } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { join, isNullOrEmpty, split } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { choose } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { value, some } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+
+const Http_defaultRequest = new HttpRequest("", HttpMethod_GET(), empty(), false, void 0, void 0, void 0, BodyContent_Empty());
+new HttpResponse(0, "", "", "", empty$1({
+  Compare: comparePrimitives
+}), ResponseContent_Text(""));
+function Http_splitAt(delimiter, input) {
+  if (isNullOrEmpty(input)) {
+    return [input];
+  } else {
+    return split(input, [delimiter], void 0, 0);
+  }
+}
+function Http_serializeMethod(_arg) {
+  switch (_arg.tag) {
+    case /* POST */
+    1:
+      return "POST";
+    case /* PATCH */
+    3:
+      return "PATCH";
+    case /* PUT */
+    2:
+      return "PUT";
+    case /* DELETE */
+    4:
+      return "DELETE";
+    case /* OPTIONS */
+    6:
+      return "OPTIONS";
+    case /* HEAD */
+    5:
+      return "HEAD";
+    default:
+      return "GET";
+  }
+}
+function Http_request(url) {
+  return new HttpRequest(url, Http_defaultRequest.method, Http_defaultRequest.headers, Http_defaultRequest.withCredentials, Http_defaultRequest.overridenMimeType, Http_defaultRequest.overridenResponseType, Http_defaultRequest.timeout, Http_defaultRequest.content);
+}
+function Http_method(httpVerb, req) {
+  return new HttpRequest(req.url, httpVerb, req.headers, req.withCredentials, req.overridenMimeType, req.overridenResponseType, req.timeout, req.content);
+}
+function Http_send(req) {
+  return fromContinuations((tupledArg) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(Http_serializeMethod(req.method), req.url);
+    xhr.onreadystatechange = () => {
+      let responseText, matchValue, statusCode, responseType, content, matchValue_1, responseHeaders;
+      if (xhr.readyState === 4) {
+        tupledArg[0]((responseText = (matchValue = xhr.responseType, matchValue === "" ? xhr.responseText : matchValue === "text" ? xhr.responseText : ""), statusCode = xhr.status | 0, responseType = xhr.responseType, content = (matchValue_1 = xhr.responseType, matchValue_1 === "" ? ResponseContent_Text(xhr.responseText) : matchValue_1 === "text" ? ResponseContent_Text(xhr.responseText) : matchValue_1 === "arraybuffer" ? ResponseContent_ArrayBuffer(xhr.response) : matchValue_1 === "blob" ? ResponseContent_Blob(xhr.response) : ResponseContent_Unknown(xhr.response)), responseHeaders = ofArray(choose((headerLine) => {
+          const matchValue_2 = ofArray$1(Http_splitAt(":", headerLine));
+          if (!isEmpty(matchValue_2)) {
+            return [head(matchValue_2).toLocaleLowerCase(), join(":", tail(matchValue_2)).trim()];
+          } else {
+            return void 0;
+          }
+        }, Http_splitAt("\r\n", xhr.getAllResponseHeaders())), {
+          Compare: comparePrimitives
+        }), new HttpResponse(statusCode, responseText, responseType, xhr.responseURL, responseHeaders, content)));
+      }
+    };
+    const enumerator = getEnumerator(req.headers);
+    try {
+      while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+        const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+        const value = forLoopVar.fields[1];
+        const key_1 = forLoopVar.fields[0];
+        xhr.setRequestHeader(key_1, value);
+      }
+    } finally {
+      disposeSafe(enumerator);
+    }
+    xhr.withCredentials = req.withCredentials;
+    const matchValue_3 = req.overridenMimeType;
+    if (matchValue_3 == null) ; else {
+      const mimeType = value(matchValue_3);
+      xhr.overrideMimeType(mimeType);
+    }
+    const matchValue_4 = req.overridenResponseType;
+    if (matchValue_4 == null) ; else {
+      switch (value(matchValue_4).tag) {
+        case /* Blob */
+        1: {
+          xhr.responseType = "blob";
+          break;
+        }
+        case /* ArrayBuffer */
+        2: {
+          xhr.responseType = "arraybuffer";
+          break;
+        }
+        default:
+          xhr.responseType = "text";
+      }
+    }
+    const matchValue_5 = req.timeout;
+    if (matchValue_5 == null) ; else {
+      const timeout = value(matchValue_5) | 0;
+      xhr.timeout = timeout | 0;
+    }
+    const matchValue_6 = req.content;
+    switch (matchValue_6.tag) {
+      case /* Text */
+      1: {
+        const value_1 = matchValue_6.fields[0];
+        xhr.send(some(value_1));
+        break;
+      }
+      case /* Form */
+      3: {
+        const formData = matchValue_6.fields[0];
+        xhr.send(some(formData));
+        break;
+      }
+      case /* Binary */
+      2: {
+        const blob = matchValue_6.fields[0];
+        xhr.send(some(blob));
+        break;
+      }
+      default:
+        xhr.send();
+    }
+  });
+}
+function Http_get(url) {
+  return singleton.Delay(() => singleton.Bind(Http_send(Http_method(HttpMethod_GET(), Http_request(url))), (_arg) => {
+    const response = _arg;
+    return singleton.Return([response.statusCode, response.responseText]);
+  }));
+}
+
+export { Http_get, Http_method, Http_request, Http_send };

package/dist/ts/ts/fable_modules/Fable.SimpleHttp.3.5.0/Types.fs.js

@@ -0,0 +1,76 @@
+import { Record, Union } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+
+function HttpMethod_GET() {
+  return new HttpMethod(0, []);
+}
+class HttpMethod extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+  }
+}
+function BodyContent_Empty() {
+  return new BodyContent(0, []);
+}
+class BodyContent extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Empty", "Text", "Binary", "Form"];
+  }
+}
+class HttpRequest extends Record {
+  constructor(url, method, headers, withCredentials, overridenMimeType, overridenResponseType, timeout, content) {
+    super();
+    this.url = url;
+    this.method = method;
+    this.headers = headers;
+    this.withCredentials = withCredentials;
+    this.overridenMimeType = overridenMimeType;
+    this.overridenResponseType = overridenResponseType;
+    this.timeout = timeout;
+    this.content = content;
+  }
+}
+function ResponseContent_Text(Item) {
+  return new ResponseContent(0, [Item]);
+}
+function ResponseContent_Blob(Item) {
+  return new ResponseContent(1, [Item]);
+}
+function ResponseContent_ArrayBuffer(Item) {
+  return new ResponseContent(2, [Item]);
+}
+function ResponseContent_Unknown(Item) {
+  return new ResponseContent(3, [Item]);
+}
+class ResponseContent extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["Text", "Blob", "ArrayBuffer", "Unknown"];
+  }
+}
+class HttpResponse extends Record {
+  constructor(statusCode, responseText, responseType, responseUrl, responseHeaders, content) {
+    super();
+    this.statusCode = statusCode | 0;
+    this.responseText = responseText;
+    this.responseType = responseType;
+    this.responseUrl = responseUrl;
+    this.responseHeaders = responseHeaders;
+    this.content = content;
+  }
+}
+
+export { BodyContent, BodyContent_Empty, HttpMethod, HttpMethod_GET, HttpRequest, HttpResponse, ResponseContent, ResponseContent_ArrayBuffer, ResponseContent_Blob, ResponseContent_Text, ResponseContent_Unknown };

package/dist/ts/ts/fable_modules/FsSpreadsheet.7.0.0-alpha.1/Cells/FsCell.fs.js

@@ -0,0 +1,359 @@
+import { toString, Union } from '../../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { parse as parse$1 } from '../../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { FsAddress, CellReference_indexToColAdress } from '../FsAddress.fs.js';
+import { toInt64, toUInt64 } from '../../../../node_modules/@fable-org/fable-library-js/BigInt.js';
+import { parse as parse$3 } from '../../../../node_modules/@fable-org/fable-library-js/Decimal.js';
+import { parse } from '../../../../node_modules/@fable-org/fable-library-js/Double.js';
+import { parse as parse$2 } from '../../../../node_modules/@fable-org/fable-library-js/Long.js';
+import { parse as parse$4 } from '../../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { parse as parse$5 } from '../../../../node_modules/@fable-org/fable-library-js/Guid.js';
+import { parse as parse$6 } from '../../../../node_modules/@fable-org/fable-library-js/Char.js';
+import { forAll } from '../../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { equals } from '../../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { defaultArg, map } from '../../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { Big } from '../../../../node_modules/@fable-org/fable-library-js/lib/big.js';
+
+function DataType_String() {
+  return new DataType(0, []);
+}
+function DataType_Boolean() {
+  return new DataType(1, []);
+}
+function DataType_Number() {
+  return new DataType(2, []);
+}
+function DataType_Date() {
+  return new DataType(3, []);
+}
+function DataType_Empty() {
+  return new DataType(4, []);
+}
+class DataType extends Union {
+  constructor(tag, fields) {
+    super();
+    this.tag = tag;
+    this.fields = fields;
+  }
+  cases() {
+    return ["String", "Boolean", "Number", "Date", "Empty"];
+  }
+}
+class FsCell {
+  constructor(value, dataType, address) {
+    this._cellValue = value;
+    this._dataType = defaultArg(dataType, DataType_String());
+    this._comment = "";
+    this._hyperlink = "";
+    this._richText = "";
+    this._formulaA1 = "";
+    this._formulaR1C1 = "";
+    this._rowIndex = defaultArg(map((a) => a.RowNumber, address), 1) | 0;
+    this._columnIndex = defaultArg(map((a_1) => a_1.ColumnNumber, address), 1) | 0;
+  }
+  get Value() {
+    const self = this;
+    return self._cellValue;
+  }
+  set Value(value) {
+    const self = this;
+    self._cellValue = value;
+  }
+  get DataType() {
+    const self = this;
+    return self._dataType;
+  }
+  set DataType(dataType) {
+    const self = this;
+    self._dataType = dataType;
+  }
+  get ColumnNumber() {
+    const self = this;
+    return self._columnIndex | 0;
+  }
+  set ColumnNumber(colI) {
+    const self = this;
+    self._columnIndex = colI | 0;
+  }
+  get RowNumber() {
+    const self = this;
+    return self._rowIndex | 0;
+  }
+  set RowNumber(rowI) {
+    const self = this;
+    self._rowIndex = rowI | 0;
+  }
+  get Address() {
+    const self = this;
+    return new FsAddress(self._rowIndex, self._columnIndex);
+  }
+  set Address(address) {
+    const self = this;
+    self._rowIndex = address.RowNumber | 0;
+    self._columnIndex = address.ColumnNumber | 0;
+  }
+  static create(rowNumber, colNumber, value) {
+    let patternInput;
+    const value_1_1 = value;
+    if (typeof value_1_1 === "string") {
+      patternInput = [DataType_String(), value_1_1];
+    } else if (typeof value_1_1 === "boolean") {
+      patternInput = value_1_1 ? [DataType_Boolean(), true] : [DataType_Boolean(), false];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "bigint") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "bigint") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (value_1_1 instanceof Big) {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (value_1_1 instanceof Date) {
+      patternInput = [DataType_Date(), value_1_1];
+    } else if (typeof value_1_1 === "string") {
+      patternInput = [DataType_String(), value_1_1];
+    } else {
+      patternInput = [DataType_String(), value_1_1];
+    }
+    return new FsCell(patternInput[1], patternInput[0], new FsAddress(rowNumber, colNumber));
+  }
+  static createEmpty() {
+    return new FsCell("", DataType_Empty(), new FsAddress(0, 0));
+  }
+  static createWithAdress(adress, value) {
+    let patternInput;
+    const value_1_1 = value;
+    if (typeof value_1_1 === "string") {
+      patternInput = [DataType_String(), value_1_1];
+    } else if (typeof value_1_1 === "boolean") {
+      patternInput = value_1_1 ? [DataType_Boolean(), true] : [DataType_Boolean(), false];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "bigint") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "bigint") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (value_1_1 instanceof Big) {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (value_1_1 instanceof Date) {
+      patternInput = [DataType_Date(), value_1_1];
+    } else if (typeof value_1_1 === "string") {
+      patternInput = [DataType_String(), value_1_1];
+    } else {
+      patternInput = [DataType_String(), value_1_1];
+    }
+    return new FsCell(patternInput[1], patternInput[0], adress);
+  }
+  static createEmptyWithAdress(adress) {
+    return new FsCell("", DataType_Empty(), adress);
+  }
+  static createWithDataType(dataType, rowNumber, colNumber, value) {
+    return new FsCell(value, dataType, new FsAddress(rowNumber, colNumber));
+  }
+  toString() {
+    const self = this;
+    return `${CellReference_indexToColAdress(self.ColumnNumber >>> 0)}${self.RowNumber} : ${self.Value} | ${self.DataType}`;
+  }
+  CopyFrom(otherCell) {
+    const self = this;
+    self.DataType = otherCell.DataType;
+    self.Value = otherCell.Value;
+  }
+  CopyTo(target) {
+    const self = this;
+    target.DataType = self.DataType;
+    target.Value = self.Value;
+  }
+  static copyFromTo(sourceCell, targetCell) {
+    targetCell.DataType = sourceCell.DataType;
+    targetCell.Value = sourceCell.Value;
+    return targetCell;
+  }
+  Copy() {
+    const self = this;
+    return new FsCell(self.Value, self.DataType, self.Address.Copy());
+  }
+  static copy(cell) {
+    return cell.Copy();
+  }
+  ValueAsString() {
+    const self = this;
+    const v = self.Value;
+    const matchValue = self.DataType;
+    switch (matchValue.tag) {
+      case /* Number */
+      2:
+        return toString(v);
+      default:
+        return toString(v);
+    }
+  }
+  static getValueAsString(cell) {
+    return cell.ValueAsString();
+  }
+  ValueAsBool() {
+    const self = this;
+    const matchValue = toString(self.Value).toLocaleLowerCase();
+    switch (matchValue) {
+      case "1":
+      case "true":
+      case "true()":
+        return true;
+      case "0":
+      case "false":
+      case "false()":
+        return false;
+      default:
+        throw new Error(`String '${matchValue}' was not recognized as a valid Boolean`);
+    }
+  }
+  static getValueAsBool(cell) {
+    return cell.ValueAsBool();
+  }
+  ValueAsFloat() {
+    const self = this;
+    return parse(toString(self.Value));
+  }
+  static getValueAsFloat(cell) {
+    return cell.ValueAsFloat();
+  }
+  ValueAsInt() {
+    const self = this;
+    return parse$1(toString(self.Value), 511, false, 32) | 0;
+  }
+  static getValueAsInt(cell) {
+    return cell.ValueAsInt();
+  }
+  ValueAsUInt() {
+    const self = this;
+    return parse$1(toString(self.Value), 511, true, 32);
+  }
+  static getValueAsUInt(cell) {
+    return cell.ValueAsUInt();
+  }
+  ValueAsLong() {
+    const self = this;
+    return toInt64(parse$2(toString(self.Value), 511, false));
+  }
+  static getValueAsLong(cell) {
+    return cell.ValueAsLong();
+  }
+  ValueAsULong() {
+    const self = this;
+    return toUInt64(parse$2(toString(self.Value), 511, true));
+  }
+  static getValueAsULong(cell) {
+    return cell.ValueAsULong();
+  }
+  ValueAsDouble() {
+    const self = this;
+    return parse(toString(self.Value));
+  }
+  static getValueAsDouble(cell) {
+    return cell.ValueAsDouble();
+  }
+  ValueAsDecimal() {
+    const self = this;
+    return parse$3(toString(self.Value));
+  }
+  static getValueAsDecimal(cell) {
+    return cell.ValueAsDecimal();
+  }
+  ValueAsDateTime() {
+    const self = this;
+    return parse$4(toString(self.Value));
+  }
+  static getValueAsDateTime(cell) {
+    return cell.ValueAsDateTime();
+  }
+  ValueAsGuid() {
+    const self = this;
+    return parse$5(toString(self.Value));
+  }
+  static getValueAsGuid(cell) {
+    return cell.ValueAsGuid();
+  }
+  ValueAsChar() {
+    const self = this;
+    return parse$6(toString(self.Value));
+  }
+  static getValueAsChar(cell) {
+    return cell.ValueAsChar();
+  }
+  SetValueAs(value) {
+    const self = this;
+    let patternInput;
+    const value_1_1 = value;
+    if (typeof value_1_1 === "string") {
+      patternInput = [DataType_String(), value_1_1];
+    } else if (typeof value_1_1 === "boolean") {
+      patternInput = value_1_1 ? [DataType_Boolean(), true] : [DataType_Boolean(), false];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "bigint") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "bigint") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (typeof value_1_1 === "number") {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (value_1_1 instanceof Big) {
+      patternInput = [DataType_Number(), value_1_1];
+    } else if (value_1_1 instanceof Date) {
+      patternInput = [DataType_Date(), value_1_1];
+    } else if (typeof value_1_1 === "string") {
+      patternInput = [DataType_String(), value_1_1];
+    } else {
+      patternInput = [DataType_String(), value_1_1];
+    }
+    self._dataType = patternInput[0];
+    self._cellValue = patternInput[1];
+  }
+  static setValueAs(value, cell) {
+    cell.SetValueAs(value);
+    return cell;
+  }
+  StructurallyEquals(other) {
+    const this$ = this;
+    return forAll((x_1) => x_1 === true, [equals(this$.Value, other.Value), equals(this$.DataType, other.DataType), forAll((x) => x === true, [this$.Address.Address === other.Address.Address, this$.Address.ColumnNumber === other.Address.ColumnNumber, this$.Address.RowNumber === other.Address.RowNumber, this$.Address.FixedColumn === other.Address.FixedColumn, this$.Address.FixedRow === other.Address.FixedRow]), this$.ColumnNumber === other.ColumnNumber, this$.RowNumber === other.RowNumber]);
+  }
+}
+
+export { DataType, DataType_Boolean, DataType_Date, DataType_Empty, DataType_Number, DataType_String, FsCell };