@backland/schema/lib/module/fields/LiteralField.js

TypeScript schema declaration and validation library with static type inference

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
import { BJSON, inspectObject } from '@backland/utils';
import { RuntimeError } from '@backland/utils';
import { getTypeName } from '@backland/utils';
import { FieldType } from './FieldType';
var PROTO_KEY = '__o.proto__';
export class LiteralField extends FieldType {
  constructor(def) {
    super({
      def: LiteralField.utils.toDef(def),
      name: 'literal'
    });
    _defineProperty(this, "parse", void 0);
    _defineProperty(this, "__isLiteralField", true);
    var expected = this.def.value;
    this.parse = this.applyParser({
      parse(input) {
        var received = LiteralField.utils.serialize(input);
        if (expected !== received) {
          throw new Error("Unexpected literal value:\nExpected:\n".concat(expected, "\nReceived:\n").concat(received));
        }
        return input;
      }
    });
  }
  static isFinalTypeDef(t) {
    return (t === null || t === void 0 ? void 0 : t.type) === 'literal';
  }
  static is(t) {
    return (t === null || t === void 0 ? void 0 : t.__isLiteralField) === true;
  }
  static isLiteralFieldDef(t) {
    return typeof (t === null || t === void 0 ? void 0 : t[PROTO_KEY]) === 'string';
  }
}
_defineProperty(LiteralField, "utils", {
  deserialize(def) {
    var isFinalDef = def && typeof def === 'object' && PROTO_KEY in def;
    if (!isFinalDef) {
      throw new Error("Invalid LiteralFieldDef: " + inspectObject(def));
    }
    var typename = getTypeName(def.value);
    if (def[PROTO_KEY] === typename) return def.value;
    try {
      return BJSON.parse(def.value);
    } catch (e) {
      throw new RuntimeError("Failed deserialize value", _objectSpread({}, def));
    }
  },
  serialize(value) {
    if (typeof value === 'string') return value;
    try {
      return BJSON.stringify(value);
    } catch (e) {
      throw new RuntimeError("Failed to serialize", {
        //
      });
    }
  },
  toDef(input) {
    if (LiteralField.isLiteralFieldDef(input)) return input;
    return {
      [PROTO_KEY]: getTypeName(input),
      value: LiteralField.utils.serialize(input)
    };
  }
});
_defineProperty(LiteralField, "create", def => {
  return new LiteralField(def);
});
//# sourceMappingURL=LiteralField.js.map