wmod-proxy/js/service/manifest.service.js

Website Modification Proxy

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ManifestError = void 0;
exports.readManifest = readManifest;

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _manifest = require("../schema/manifest.schema");

var _model = require("../model");

var _utils = require("../utils");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

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) { (0, _defineProperty2["default"])(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 readManifest(input) {
  var res = _manifest.schemaManifest.safeParse(input); // try {


  if (!res.success) {
    var formatted = res.error.format(); // throw new ZodValidationError(formatted);

    throw new ManifestError(formatZodErrors(formatted));
  }

  var manifest = res.data; // Make helper search map

  var scriptByName = manifest.scripts.reduce(function (accum, _ref) {
    var name = _ref.name,
        files = _ref.files;

    if (accum[name] != null) {
      throw new ManifestError("script \"".concat(name, "\" is not unique"));
    }

    accum[name] = files;
    return accum;
  }, {});
  return _objectSpread(_objectSpread({}, manifest), {}, {
    rules: manifest.rules.map(function (rule) {
      return _objectSpread(_objectSpread({}, rule), {}, {
        action: (0, _model.isManifestRuleActionScripts)(rule.action) ? {
          files: rule.action.scripts.reduce(function (accum, scriptName) {
            if (scriptByName[scriptName] != null) {
              accum = accum.concat(scriptByName[scriptName]);
            } else {
              throw new ManifestError("script \"".concat(scriptName, "\" not found"));
            }

            return accum;
          }, [])
        } : rule.action
      });
    })
  });
}

var ManifestError = /*#__PURE__*/function (_Error) {
  (0, _inherits2["default"])(ManifestError, _Error);

  var _super = _createSuper(ManifestError);

  function ManifestError() {
    (0, _classCallCheck2["default"])(this, ManifestError);
    return _super.apply(this, arguments);
  }

  (0, _createClass2["default"])(ManifestError, [{
    key: "toString",
    value: function toString() {
      return 'Manifest is malformed:\n' + this.message;
    }
  }]);
  return ManifestError;
}( /*#__PURE__*/(0, _wrapNativeSuper2["default"])(Error));

exports.ManifestError = ManifestError;

function formatZodErrors(formatted) {
  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  var output = '';

  if (formatted['_errors'] != null && Array.isArray(formatted['_errors']) && formatted['_errors'].length > 0) {
    output += "".concat(path, ": ") + formatted['_errors'].join('; ') + '\n';
  }

  var props = _utils.BetterObject.keys(formatted);

  props.forEach(function (prop) {
    if (prop !== '_errors') {
      var item = formatted[prop];

      if ((0, _utils.isRecord)(item)) {
        output += formatZodErrors(item, "".concat(path !== '' ? path + '.' : '').concat(prop));
      }
    }
  });
  return output;
}
//# sourceMappingURL=manifest.service.js.map