@dlillyatx/dc-cli/dist/common/filter/facet.js

Dynamic Content CLI Tool

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.withOldFilters = exports.applyFacet = exports.dateRangeMatch = exports.relativeDate = exports.parseDateRange = exports.parseFacet = void 0;
const filter_1 = require("./filter");
function parseFacet(filter) {
    const result = {};
    let searchIndex = 0;
    while (searchIndex < filter.length) {
        const keyEnd = filter.indexOf(':', searchIndex);
        if (keyEnd == -1)
            break;
        const key = filter.substring(searchIndex, keyEnd).trimLeft();
        let valueEnd = filter.length;
        let valueEndSearch = keyEnd;
        while (valueEndSearch < filter.length) {
            const potentialValueEnd = filter.indexOf(',', valueEndSearch);
            if (potentialValueEnd == -1) {
                break;
            }
            else if (filter[potentialValueEnd - 1] == '\\') {
                valueEndSearch = potentialValueEnd + 1;
            }
            else {
                valueEnd = potentialValueEnd;
                break;
            }
        }
        const value = filter.substring(keyEnd + 1, valueEnd).replace(/\\\,/g, ',');
        result[key] = value;
        searchIndex = valueEnd + 1;
    }
    return result;
}
exports.parseFacet = parseFacet;
function parseDateRange(range) {
    if (typeof range === 'string') {
        switch (range) {
            case 'Last 7 days':
                return { start: 'NOW', end: '-7:DAYS' };
            case 'Last 14 days':
                return { start: 'NOW', end: '-14:DAYS' };
            case 'Last 30 days':
                return { start: 'NOW', end: '-30:DAYS' };
            case 'Last 60 days':
                return { start: 'NOW', end: '-60:DAYS' };
            case 'Over 60 days':
                return { start: '-60:DAYS', end: '-100:YEARS' };
            default:
                throw new Error(`Unexpected date range string: ${range}`);
        }
    }
    return range;
}
exports.parseDateRange = parseDateRange;
function relativeDate(relative) {
    if (relative === 'NOW')
        return new Date();
    const date = new Date();
    const split = relative.split(':');
    if (split.length != 2) {
        throw new Error(`Unexpected relative date format: ${relative}`);
    }
    const unit = split[1];
    switch (unit) {
        case 'DAYS':
            date.setDate(date.getDate() + Number(split[0]));
            return date;
        default:
            throw new Error(`Unexpected relative date units: ${unit}`);
    }
}
exports.relativeDate = relativeDate;
function dateRangeMatch(dateString, range) {
    const date = new Date(dateString);
    range = parseDateRange(range);
    const start = relativeDate(range.start);
    const end = relativeDate(range.end);
    const inverted = start > end;
    const lower = inverted ? end : start;
    const higher = inverted ? start : end;
    return date > lower && date <= higher;
}
exports.dateRangeMatch = dateRangeMatch;
function applyFacet(items, facetOrString) {
    let facet;
    if (typeof facetOrString === 'string') {
        facet = parseFacet(facetOrString);
    }
    else {
        facet = facetOrString;
    }
    return items.filter(item => {
        if (facet.locale && (!item.locale || !filter_1.equalsOrRegex(item.locale, facet.locale)))
            return false;
        if (facet.name && !filter_1.equalsOrRegex(item.label, facet.name))
            return false;
        if (facet.schema && !filter_1.equalsOrRegex(item.body._meta.schema, facet.schema))
            return false;
        if (facet.status && !filter_1.equalsOrRegex(item.status, facet.status))
            return false;
        if (facet.lastModifiedDate && !dateRangeMatch(item.lastModifiedDate, facet.lastModifiedDate))
            return false;
        return true;
    });
}
exports.applyFacet = applyFacet;
function escapeForRegex(url) {
    return url.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}
function combineFilters(filters) {
    if (!Array.isArray(filters)) {
        return filters;
    }
    const regexElements = [];
    for (const filter of filters) {
        if (filter.length > 2 && filter[0] === '/' && filter[filter.length - 1] === '/') {
            regexElements.push(`(${filter.substr(1, filter.length - 2)})`);
        }
        else {
            regexElements.push(`^${escapeForRegex(filter)}$`);
        }
    }
    return `/${regexElements.join('|')}/`;
}
function getOldFilter(filters, name) {
    return `${name}:${combineFilters(filters)}`;
}
function withOldFilters(facet, args) {
    if (facet || !(args.name || args.schemaId)) {
        return facet;
    }
    const resultFilters = [];
    if (args.name) {
        resultFilters.push(getOldFilter(args.name, 'name'));
    }
    if (args.schemaId) {
        resultFilters.push(getOldFilter(args.schemaId, 'schema'));
    }
    return resultFilters.map(filter => filter.replace(/\,/g, '\\,')).join(',');
}
exports.withOldFilters = withOldFilters;