@nocobase/database 0.9.0-alpha.2 → 0.9.1-alpha.1

package/lib/utils.js

@@ -4,8 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.checkIdentifier = checkIdentifier;
+exports.getTableName = getTableName;
 exports.handleAppendsQuery = handleAppendsQuery;
 exports.md5 = md5;
+exports.patchSequelizeQueryInterface = patchSequelizeQueryInterface;
+exports.percent2float = percent2float;
+exports.snakeCase = snakeCase;
 
 function _crypto() {
   const data = _interopRequireDefault(require("crypto"));
@@ -128,4 +132,68 @@ function checkIdentifier(value) {
   if (value.length > MAX_IDENTIFIER_LENGTH) {
     throw new _identifierError.IdentifierError(`Identifier ${value} is too long`);
   }
+}
+
+function getTableName(collectionName, options) {
+  return options.underscored ? snakeCase(collectionName) : collectionName;
+}
+
+function snakeCase(name) {
+  return require('sequelize').Utils.underscore(name);
+}
+
+function patchShowConstraintsQuery(queryGenerator, db) {
+  queryGenerator.showConstraintsQuery = (tableName, constraintName) => {
+    const lines = ['SELECT constraint_catalog AS "constraintCatalog",', 'constraint_schema AS "constraintSchema",', 'constraint_name AS "constraintName",', 'table_catalog AS "tableCatalog",', 'table_schema AS "tableSchema",', 'table_name AS "tableName",', 'constraint_type AS "constraintType",', 'is_deferrable AS "isDeferrable",', 'initially_deferred AS "initiallyDeferred"', 'from INFORMATION_SCHEMA.table_constraints', `WHERE table_name='${tableName}'`];
+
+    if (!constraintName) {
+      lines.push(`AND constraint_name='${constraintName}'`);
+    }
+
+    if (db.options.schema && db.options.schema !== 'public') {
+      lines.push(`AND table_schema='${db.options.schema}'`);
+    }
+
+    return lines.join(' ');
+  };
+}
+
+function patchDescribeTableQuery(queryGenerator) {
+  const describeTableQuery = function describeTableQuery(tableName, schema) {
+    schema = schema || this.options.schema || 'public';
+    return 'SELECT ' + 'pk.constraint_type as "Constraint",' + 'c.column_name as "Field", ' + 'c.column_default as "Default",' + 'c.is_nullable as "Null", ' + "(CASE WHEN c.udt_name = 'hstore' THEN c.udt_name ELSE c.data_type END) || (CASE WHEN c.character_maximum_length IS NOT NULL THEN '(' || c.character_maximum_length || ')' ELSE '' END) as \"Type\", " + '(SELECT array_agg(e.enumlabel) FROM pg_catalog.pg_type t JOIN pg_catalog.pg_enum e ON t.oid=e.enumtypid WHERE t.typname=c.udt_name) AS "special", ' + '(SELECT pgd.description FROM pg_catalog.pg_statio_all_tables AS st INNER JOIN pg_catalog.pg_description pgd on (pgd.objoid=st.relid) WHERE c.ordinal_position=pgd.objsubid AND c.table_name=st.relname AND st.schemaname = c.table_schema) AS "Comment" ' + 'FROM information_schema.columns c ' + 'LEFT JOIN (SELECT tc.table_schema, tc.table_name, ' + 'cu.column_name, tc.constraint_type ' + 'FROM information_schema.TABLE_CONSTRAINTS tc ' + 'JOIN information_schema.KEY_COLUMN_USAGE  cu ' + 'ON tc.table_schema=cu.table_schema and tc.table_name=cu.table_name ' + 'and tc.constraint_name=cu.constraint_name ' + "and tc.constraint_type='PRIMARY KEY') pk " + 'ON pk.table_schema=c.table_schema ' + 'AND pk.table_name=c.table_name ' + 'AND pk.column_name=c.column_name ' + `WHERE c.table_name = ${this.escape(tableName)} AND c.table_schema = ${this.escape(schema)}`;
+  };
+
+  queryGenerator.describeTableQuery = describeTableQuery.bind(queryGenerator);
+}
+
+function patchSequelizeQueryInterface(db) {
+  if (db.inDialect('postgres')) {
+    //@ts-ignore
+    const queryGenerator = db.sequelize.dialect.queryGenerator;
+    patchShowConstraintsQuery(queryGenerator, db);
+    patchDescribeTableQuery(queryGenerator);
+  }
+}
+
+function percent2float(value) {
+  if (!value.endsWith('%')) {
+    return NaN;
+  }
+
+  let val = value.substring(0, value.length - 1);
+
+  if (isNaN(+val)) {
+    return NaN;
+  }
+
+  const index = value.indexOf('.');
+
+  if (index === -1) {
+    return parseFloat(value) / 100;
+  }
+
+  const repeat = value.length - index - 2;
+  const v = parseInt('1' + '0'.repeat(repeat));
+  return parseFloat(value) * v / (100 * v);
 }

package/lib/value-parsers/array-value-parser.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class ArrayValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+    getOptions(): {
+        map: Map<any, any>;
+        set: Set<unknown>;
+    };
+}

package/lib/value-parsers/array-value-parser.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrayValueParser = void 0;
+
+var _baseValueParser = require("./base-value-parser");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class ArrayValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const _this$getOptions = _this.getOptions(),
+            map = _this$getOptions.map,
+            set = _this$getOptions.set;
+
+      const values = _this.toArr(value);
+
+      if (set.size > 0) {
+        const filtered = values.map(v => map.has(v) ? map.get(v) : v).filter(v => set.has(v));
+
+        if (values.length === filtered.length) {
+          _this.value = filtered;
+        } else {
+          _this.errors.push(`No matching option found - ${JSON.stringify(value)}`);
+        }
+      } else {
+        _this.value = values;
+      }
+    })();
+  }
+
+  getOptions() {
+    var _this$field$options, _this$field$options$u;
+
+    const options = ((_this$field$options = this.field.options) === null || _this$field$options === void 0 ? void 0 : (_this$field$options$u = _this$field$options['uiSchema']) === null || _this$field$options$u === void 0 ? void 0 : _this$field$options$u.enum) || [];
+    const map = new Map();
+    const set = new Set();
+
+    var _iterator = _createForOfIteratorHelper(options),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const option = _step.value;
+        set.add(option.value);
+        set.add(option.label);
+        map.set(option.label, option.value);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return {
+      map,
+      set
+    };
+  }
+
+}
+
+exports.ArrayValueParser = ArrayValueParser;

package/lib/value-parsers/base-value-parser.d.ts

@@ -0,0 +1,12 @@
+export declare class BaseValueParser {
+    ctx: any;
+    field: any;
+    value: any;
+    errors: string[];
+    constructor(field: any, ctx: any);
+    trim(value: any): any;
+    toArr(value: any, splitter?: string): any[];
+    toString(): any;
+    getValue(): any;
+    setValue(value: any): Promise<void>;
+}

package/lib/value-parsers/base-value-parser.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseValueParser = void 0;
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class BaseValueParser {
+  constructor(field, ctx) {
+    this.ctx = void 0;
+    this.field = void 0;
+    this.value = void 0;
+    this.errors = [];
+    this.field = field;
+    this.ctx = ctx;
+    this.value = null;
+  }
+
+  trim(value) {
+    return typeof value === 'string' ? value.trim() : value;
+  }
+
+  toArr(value, splitter) {
+    let values = [];
+
+    if (!value) {
+      values = [];
+    } else if (typeof value === 'string') {
+      values = value.split(splitter || /,|，|、/);
+    } else if (Array.isArray(value)) {
+      values = value;
+    }
+
+    return values.map(v => this.trim(v)).filter(Boolean);
+  }
+
+  toString() {
+    return this.value;
+  }
+
+  getValue() {
+    return this.value;
+  }
+
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      _this.value = value;
+    })();
+  }
+
+}
+
+exports.BaseValueParser = BaseValueParser;

package/lib/value-parsers/boolean-value-parser.d.ts

@@ -0,0 +1,4 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class BooleanValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+}

package/lib/value-parsers/boolean-value-parser.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BooleanValueParser = void 0;
+
+var _baseValueParser = require("./base-value-parser");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class BooleanValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // Boolean
+      if (typeof value === 'boolean') {
+        _this.value = value;
+      } // Number
+      else if (typeof value === 'number' && [0, 1].includes(value)) {
+        _this.value = value === 1;
+      } // String
+      else if (typeof value === 'string') {
+        if (!value) {
+          _this.value = null;
+        }
+
+        if (['1', 'y', 'yes', 'true', '是'].includes(value.toLowerCase())) {
+          _this.value = true;
+        } else if (['0', 'n', 'no', 'false', '否'].includes(value.toLowerCase())) {
+          _this.value = false;
+        } else {
+          _this.errors.push(`Invalid value - ${JSON.stringify(_this.value)}`);
+        }
+      } else {
+        _this.errors.push(`Invalid value - ${JSON.stringify(_this.value)}`);
+      }
+    })();
+  }
+
+}
+
+exports.BooleanValueParser = BooleanValueParser;

package/lib/value-parsers/date-value-parser.d.ts

@@ -0,0 +1,5 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class DateValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+    getProps(): any;
+}

package/lib/value-parsers/date-value-parser.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateValueParser = void 0;
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _excelDateToJs() {
+  const data = require("excel-date-to-js");
+
+  _excelDateToJs = function _excelDateToJs() {
+    return data;
+  };
+
+  return data;
+}
+
+function _moment() {
+  const data = _interopRequireWildcard(require("moment"));
+
+  _moment = function _moment() {
+    return data;
+  };
+
+  return data;
+}
+
+var _baseValueParser = require("./base-value-parser");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function isNumeric(str) {
+  if (typeof str === 'number') return true;
+  if (typeof str != 'string') return false;
+  return !isNaN(str) && !isNaN(parseFloat(str));
+}
+
+class DateValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if ((0, _moment().isMoment)(value)) {
+        _this.value = value;
+      } else if ((0, _moment().isDate)(value)) {
+        _this.value = value;
+      } else if (isNumeric(value)) {
+        try {
+          _this.value = (0, _excelDateToJs().getJsDateFromExcel)(value).toISOString();
+        } catch (error) {
+          _this.errors.push(`Invalid date - ${error.message}`);
+        }
+      } else if (typeof value === 'string') {
+        const props = _this.getProps();
+
+        const m = (0, _moment().default)(value);
+
+        if (m.isValid()) {
+          _this.value = (0, _utils().moment2str)(m, props);
+        } else {
+          _this.errors.push('Invalid date');
+        }
+      }
+    })();
+  }
+
+  getProps() {
+    var _this$field$options, _this$field$options$u;
+
+    return ((_this$field$options = this.field.options) === null || _this$field$options === void 0 ? void 0 : (_this$field$options$u = _this$field$options.uiSchema) === null || _this$field$options$u === void 0 ? void 0 : _this$field$options$u['x-component-props']) || {};
+  }
+
+}
+
+exports.DateValueParser = DateValueParser;

package/lib/value-parsers/index.d.ts

@@ -0,0 +1,12 @@
+import { Database } from '../database';
+import { ArrayValueParser } from './array-value-parser';
+import { BaseValueParser } from './base-value-parser';
+import { BooleanValueParser } from './boolean-value-parser';
+import { DateValueParser } from './date-value-parser';
+import { JsonValueParser } from './json-value-parser';
+import { NumberValueParser } from './number-value-parser';
+import { StringValueParser } from './string-value-parser';
+import { ToManyValueParser } from './to-many-value-parser';
+import { ToOneValueParser } from './to-one-value-parser';
+export declare function registerFieldValueParsers(db: Database): void;
+export { ArrayValueParser, BaseValueParser, BooleanValueParser, DateValueParser, JsonValueParser, NumberValueParser, StringValueParser, ToManyValueParser, ToOneValueParser, };

package/lib/value-parsers/index.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ArrayValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _arrayValueParser.ArrayValueParser;
+  }
+});
+Object.defineProperty(exports, "BaseValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _baseValueParser.BaseValueParser;
+  }
+});
+Object.defineProperty(exports, "BooleanValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _booleanValueParser.BooleanValueParser;
+  }
+});
+Object.defineProperty(exports, "DateValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _dateValueParser.DateValueParser;
+  }
+});
+Object.defineProperty(exports, "JsonValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _jsonValueParser.JsonValueParser;
+  }
+});
+Object.defineProperty(exports, "NumberValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _numberValueParser.NumberValueParser;
+  }
+});
+Object.defineProperty(exports, "StringValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _stringValueParser.StringValueParser;
+  }
+});
+Object.defineProperty(exports, "ToManyValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _toManyValueParser.ToManyValueParser;
+  }
+});
+Object.defineProperty(exports, "ToOneValueParser", {
+  enumerable: true,
+  get: function get() {
+    return _toOneValueParser.ToOneValueParser;
+  }
+});
+exports.registerFieldValueParsers = registerFieldValueParsers;
+
+var _arrayValueParser = require("./array-value-parser");
+
+var _baseValueParser = require("./base-value-parser");
+
+var _booleanValueParser = require("./boolean-value-parser");
+
+var _dateValueParser = require("./date-value-parser");
+
+var _jsonValueParser = require("./json-value-parser");
+
+var _numberValueParser = require("./number-value-parser");
+
+var _stringValueParser = require("./string-value-parser");
+
+var _toManyValueParser = require("./to-many-value-parser");
+
+var _toOneValueParser = require("./to-one-value-parser");
+
+function registerFieldValueParsers(db) {
+  db.registerFieldValueParsers({
+    default: _baseValueParser.BaseValueParser,
+    array: _arrayValueParser.ArrayValueParser,
+    set: _arrayValueParser.ArrayValueParser,
+    boolean: _booleanValueParser.BooleanValueParser,
+    date: _dateValueParser.DateValueParser,
+    json: _jsonValueParser.JsonValueParser,
+    jsonb: _jsonValueParser.JsonValueParser,
+    number: _numberValueParser.NumberValueParser,
+    integer: _numberValueParser.NumberValueParser,
+    bigInt: _numberValueParser.NumberValueParser,
+    float: _numberValueParser.NumberValueParser,
+    double: _numberValueParser.NumberValueParser,
+    real: _numberValueParser.NumberValueParser,
+    decimal: _numberValueParser.NumberValueParser,
+    string: _stringValueParser.StringValueParser,
+    hasOne: _toOneValueParser.ToOneValueParser,
+    hasMany: _toManyValueParser.ToManyValueParser,
+    belongsTo: _toOneValueParser.ToOneValueParser,
+    belongsToMany: _toManyValueParser.ToManyValueParser
+  });
+}

package/lib/value-parsers/json-value-parser.d.ts

@@ -0,0 +1,4 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class JsonValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+}

package/lib/value-parsers/json-value-parser.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JsonValueParser = void 0;
+
+var _baseValueParser = require("./base-value-parser");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class JsonValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if (typeof value === 'string') {
+        if (value.trim() === '') {
+          _this.value = null;
+        } else {
+          try {
+            _this.value = JSON.parse(value);
+          } catch (error) {
+            _this.errors.push(error.message);
+          }
+        }
+      } else {
+        _this.value = value;
+      }
+    })();
+  }
+
+}
+
+exports.JsonValueParser = JsonValueParser;

package/lib/value-parsers/number-value-parser.d.ts

@@ -0,0 +1,4 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class NumberValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+}

package/lib/value-parsers/number-value-parser.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NumberValueParser = void 0;
+
+var _utils = require("../utils");
+
+var _baseValueParser = require("./base-value-parser");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class NumberValueParser extends _baseValueParser.BaseValueParser {
+  setValue(value) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      if (value === null || value === undefined || typeof value === 'number') {
+        _this.value = value;
+      } else if (typeof value === 'string') {
+        if (!value) {
+          _this.value = null;
+        } else if (['n/a', '-'].includes(value.toLowerCase())) {
+          _this.value = null;
+        } else {
+          if (value.endsWith('%')) {
+            value = (0, _utils.percent2float)(value);
+          } else {
+            value = +value;
+          }
+
+          if (isNaN(value)) {
+            _this.errors.push(`Invalid value - "${value}"`);
+          } else {
+            _this.value = value;
+          }
+        }
+      } else {
+        _this.errors.push(`Invalid value - ${JSON.stringify(value)}`);
+      }
+    })();
+  }
+
+}
+
+exports.NumberValueParser = NumberValueParser;

package/lib/value-parsers/string-value-parser.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueParser } from './base-value-parser';
+export declare class StringValueParser extends BaseValueParser {
+    setValue(value: any): Promise<void>;
+    getOptions(): {
+        map: Map<any, any>;
+        set: Set<unknown>;
+    };
+}