@barchart/common-js/dist/cjs/api/http/builders/ParametersBuilder.js

Library of common JavaScript utilities

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var ParametersBuilder_exports = {};
__export(ParametersBuilder_exports, {
  default: () => ParametersBuilder
});
module.exports = __toCommonJS(ParametersBuilder_exports);
var assert = __toESM(require("./../../../lang/assert.js"));
var attributes = __toESM(require("./../../../lang/attributes.js"));
var is = __toESM(require("./../../../lang/is.js"));
var import_Parameter = __toESM(require("./../definitions/Parameter.js"));
var import_Parameters = __toESM(require("./../definitions/Parameters.js"));
class ParametersBuilder {
  #parameters;
  #required;
  /**
   * @param {boolean=} required - If true, all parameters will be marked as required.
   */
  constructor(required) {
    this.#parameters = new import_Parameters.default();
    this.#required = is.boolean(required) && required;
  }
  /**
   * The {@link Parameters} collection, given all the information provided thus far.
   *
   * @public
   * @returns {Parameters}
   */
  get parameters() {
    return this.#parameters;
  }
  /**
   * Adds a new parameter that extracts its value from a delegate.
   *
   * @param {string} description
   * @param {string} key
   * @param {Function} delegate
   * @param {boolean=} optional
   * @param {Function=} serializer
   * @returns {ParametersBuilder}
   */
  withDelegateParameter(description, key, delegate, optional, serializer) {
    this.#addParameter(new import_Parameter.default(description, key, buildDelegateExtractor(delegate, buildSerializer(serializer)), optional || this.#required));
    return this;
  }
  /**
   * Adds a new parameter with a literal value.
   *
   * @param {string} description
   * @param {string} key
   * @param {*=} value
   * @param {boolean=} optional
   * @returns {ParametersBuilder}
   */
  withLiteralParameter(description, key, value, optional) {
    this.#addParameter(new import_Parameter.default(description, key, buildLiteralExtractor(value || key), optional || this.#required));
    return this;
  }
  /**
   * Adds a new parameter that reads its value from the variable
   * on the request payload.
   *
   * @param {string} description
   * @param {string} key
   * @param {string} variable
   * @param {boolean=} optional
   * @param {Function=} serializer
   * @returns {ParametersBuilder}
   */
  withVariableParameter(description, key, variable, optional, serializer) {
    this.#addParameter(new import_Parameter.default(description, key, buildVariableExtractor(variable, buildSerializer(serializer)), optional || this.#required));
    return this;
  }
  /**
   * Returns a string representation.
   *
   * @public
   * @returns {string}
   */
  toString() {
    return "[ParametersBuilder]";
  }
  #addParameter(parameter) {
    const items = this.#parameters.parameters.slice(0);
    items.push(parameter);
    this.#parameters = new import_Parameters.default(items);
  }
}
function buildSerializer(serializer) {
  let returnRef;
  if (is.fn(serializer)) {
    returnRef = serializer;
  } else {
    returnRef = (x) => x;
  }
  return returnRef;
}
function buildDelegateExtractor(fn, serializer) {
  assert.argumentIsRequired(fn, "fn", Function);
  return async (payload) => {
    return serializer(fn(payload));
  };
}
function buildLiteralExtractor(value) {
  assert.argumentIsRequired(value, "value", String);
  return async () => value;
}
function buildVariableExtractor(variable, serializer) {
  assert.argumentIsRequired(variable, "variable", String);
  return buildDelegateExtractor((payload) => {
    if (is.object(payload) && attributes.has(payload, variable)) {
      return attributes.read(payload, variable);
    } else {
      return null;
    }
  }, serializer);
}

{
	const cjsExports = module.exports;
	const cjsDefaultExport = cjsExports && cjsExports.__esModule ? cjsExports.default : cjsExports;

	if (cjsDefaultExport && (typeof cjsDefaultExport === 'function' || typeof cjsDefaultExport === 'object')) {
		Object.keys(cjsExports).forEach((key) => {
			if (key !== 'default' && key !== '__esModule') {
				cjsDefaultExport[key] = cjsExports[key];
			}
		});
	}

	module.exports = cjsDefaultExport;
}