"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValueMapRange = void 0;
const index_js_1 = require("../model/index.js");
const util = __importStar(require("../util/index.js"));
class ValueMapRange extends index_js_1.Pipe {
    constructor() {
        super(...arguments);
        this.ranges = [];
    }
    async apply(inputSet, _ctx) {
        return this.map(inputSet, el => {
            util.checkType(el.value, 'number');
            const newValue = util.mapRange(this.ranges, el.value);
            return el.clone(newValue);
        });
    }
}
ValueMapRange.$type = 'Number.mapRange';
ValueMapRange.$help = `
Returns a string value corresponding to one of the configured numeric ranges where the input value belongs to.

The configured ranges must cover the expected numeric domain and must not overlap to prevent ambiguity.

The lower bounds of are always inclusive, whereas the upper bounds are always exclusive.
Therefore, ranges \`[0, 3)\` and \`[3, 5)\` form a continuous range \`[0, 5)\` with no "holes" in it;
and the input value \`3\` will belong to the second range.

An error is thrown if input value is not a number, or if the number does not belong to any range.

### Use For

- mapping continuous ranges into discrete categories (e.g. passenger age groups)
`;
__decorate([
    index_js_1.params.Recordset({
        singular: 'range',
        fields: [
            {
                name: 'value',
                type: 'string',
                value: '',
            },
            {
                name: 'min',
                type: 'number',
                value: null,
            },
            {
                name: 'max',
                type: 'number',
                value: null,
            },
        ],
        help: `
List of range-to-value mappings:

- value: an output value which is returned if input value belongs to this range
- min: a number, the lower bound of this range (inclusive); if omitted, -Infinity is implied
- max: a number, the upper bound of this range (exclusive); if omitted, +Infinity is implied
`,
    }),
    __metadata("design:type", Array)
], ValueMapRange.prototype, "ranges", void 0);
exports.ValueMapRange = ValueMapRange;
//# sourceMappingURL=Number.mapRange.js.map