@firestitch/report 18.9.0 → 18.10.1

package/esm2022/app/reports/filter-settings-rules.mjs

@@ -0,0 +1,290 @@
+import { RELATIVE_RANGE_NAMES, isRelativeRange } from './report-view-config';
+import { offersExclude } from './report-viewer-features';
+// The Type select's choices. A column that can be either holds both.
+export const FILTER_TYPE_OPTIONS = [
+    { value: 'select', name: 'Values' },
+    { value: 'numberRange', name: 'Number range' },
+];
+export const TYPE_LOCKED_TOOLTIP = 'Remove the filter to change its type.';
+export const PAGE_FILTER_TOOLTIP = 'A page filter shows in the page bar only.';
+export const COMPONENT_TOGGLE_TOOLTIP = 'Show on this component';
+// The Default period select's value for a range of fixed days. No relative
+// range is named this.
+export const FIXED_DATES_PERIOD = 'fixed';
+// How many decimals a Default minimum or Default maximum takes.
+export const DEFAULT_BOUND_SCALE = 6;
+// A filter's Name and Label, checked as the server checks them, so a bad one
+// is caught before Save. The name is an identifier: a letter, then letters
+// and digits. That it is unique in the report is the server's to check.
+export const FILTER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+export const FILTER_NAME_PATTERN_MESSAGE = 'A name starts with a letter and holds only letters and digits.';
+export const FILTER_NAME_MAX_LENGTH = 50;
+export const FILTER_LABEL_MAX_LENGTH = 200;
+// Every Report bar choice, in the order the select lists them.
+const BAR_PLACEMENT_OPTIONS = [
+    { value: 'off', name: 'Off' },
+    { value: 'every', name: 'Every page' },
+    { value: 'page', name: 'This page only' },
+];
+// A number with its group commas in place ('1,250.5', '-12,000').
+const GROUPED_DECIMAL = /^-?\d{1,3}(,\d{3})+(\.\d*)?$/;
+// A plain decimal number ('1250.5', '-3', '0', '.5'). Hex, binary, octal,
+// exponents and inner spaces do not match, though Number() reads some.
+const PLAIN_DECIMAL = /^-?(\d+(\.\d*)?|\.\d+)$/;
+// A default range end as typed. An empty field is no end. A number input
+// with a mask hands back text with its group commas ('1,250.5'), so those go
+// before Number() reads it; 0 is an end like any other. Anything that is not
+// a decimal number is no end.
+export function parseDefaultBound(raw) {
+    if (typeof raw === 'number') {
+        return Number.isFinite(raw) ? raw : null;
+    }
+    if (typeof raw !== 'string') {
+        return null;
+    }
+    const trimmed = raw.trim();
+    const text = GROUPED_DECIMAL.test(trimmed) ? trimmed.replace(/,/g, '') : trimmed;
+    if (!PLAIN_DECIMAL.test(text)) {
+        return null;
+    }
+    const value = Number(text);
+    return Number.isFinite(value) ? value : null;
+}
+// Why two range ends cannot be saved, in the server's words, or null. An open
+// end is always fine.
+export function boundsError(min, max) {
+    if (min === null || max === null || min <= max) {
+        return null;
+    }
+    return `min (${min}) is above max (${max}).`;
+}
+// The Type select of a column on the component settings' Filters tab. It
+// shows when the column can take either type and the server serves number
+// ranges (an older server lists no features). A filter's type cannot change,
+// so it is locked while the column has a filter on this component.
+export function typeSelectState(types, hasFilterOnThisComponent, features) {
+    const show = (features ?? []).includes('numberRange')
+        && FILTER_TYPE_OPTIONS.every((option) => (types ?? []).includes(option.value));
+    if (!show) {
+        return { show: false, disabled: false, tooltip: null };
+    }
+    return {
+        show: true,
+        disabled: hasFilterOnThisComponent,
+        tooltip: hasFilterOnThisComponent ? TYPE_LOCKED_TOOLTIP : null,
+    };
+}
+// The levels a new or moved filter can take on a component. This page only
+// needs a server that serves page filters and a component on a page (a
+// header or footer component is on no page).
+export function filterLevelChoices(features, onPage) {
+    const levels = ['component', 'report', 'both'];
+    return onPage && (features ?? []).includes('pageScope')
+        ? [...levels, 'page']
+        : levels;
+}
+// The Report bar select's choices for the levels on offer. The choice a row
+// already holds is always listed, so the select never shows blank.
+export function barPlacementOptions(levelChoices, current = 'off') {
+    return BAR_PLACEMENT_OPTIONS.filter((option) => {
+        switch (option.value) {
+            case 'every':
+                return levelChoices.includes('report') || levelChoices.includes('both') || current === 'every';
+            case 'page':
+                return levelChoices.includes('page') || current === 'page';
+            default:
+                return true;
+        }
+    });
+}
+// A value's Report bar choices. A value has no strip of its own and its
+// group may be shared, so a pick never lowers the group (the inline values
+// rule): This page only is offered for a new filter, or for a group that is
+// already a page group, never to move a shared group to one page.
+export function valuePlacementOptions(levelChoices, current) {
+    const choices = !current || current === 'page'
+        ? levelChoices
+        : levelChoices.filter((level) => level !== 'page');
+    return barPlacementOptions(choices, barPlacement(current));
+}
+// The level a value's filter group ends at after a Report bar pick, or null
+// when the value leaves it. Off unlinks this value alone and the group keeps
+// its other members. A new filter takes the pick's level. Every page raises a
+// strip-only group to both, keeping its strips, and a page group to the
+// report bar. Nothing else moves the group, so a value never lowers it.
+export function valueFilterLevel(placement, current) {
+    if (placement === 'off') {
+        return null;
+    }
+    if (!current) {
+        return placement === 'page' ? 'page' : 'report';
+    }
+    if (placement !== 'every') {
+        return current;
+    }
+    switch (current) {
+        case 'component':
+            return 'both';
+        case 'page':
+            return 'report';
+        default:
+            return current;
+    }
+}
+// Where a group of a level shows in the report bar. No group (no filter) is
+// off.
+export function barPlacement(level) {
+    switch (level) {
+        case 'report':
+        case 'both':
+            return 'every';
+        case 'page':
+            return 'page';
+        default:
+            return 'off';
+    }
+}
+// Whether a group of a level shows on its components.
+export function shownOnComponent(level) {
+    return level === 'component' || level === 'both';
+}
+// The level the two controls of a row ask for, or null when they ask for no
+// filter at all. A page filter shows in its page's bar only, so This page
+// only ignores the This component toggle.
+export function filterLevel(placement, component) {
+    switch (placement) {
+        case 'page':
+            return 'page';
+        case 'every':
+            return component ? 'both' : 'report';
+        default:
+            return component ? 'component' : null;
+    }
+}
+// The This component toggle of a row: locked while This page only is picked.
+export function componentToggleState(placement) {
+    return placement === 'page'
+        ? { disabled: true, tooltip: PAGE_FILTER_TOOLTIP }
+        : { disabled: false, tooltip: COMPONENT_TOGGLE_TOOLTIP };
+}
+// The groups the report settings' Filters tab lists defaults for: those of
+// the report bar, every page or one, in bar order.
+export function defaultRowGroups(groups) {
+    return (groups ?? [])
+        .filter((group) => group.level === 'report' || group.level === 'both' || group.level === 'page')
+        .sort((a, b) => a.order - b.order);
+}
+// A default row's label: a page group names its page, 'Region (page
+// "Overview")'. A page with no name reads as the canvas names it ('Page 2').
+// A page this report no longer holds adds nothing.
+export function defaultRowLabel(group, pages) {
+    const label = group.label || group.filters?.[0]?.filterColumn || 'Filter';
+    if (group.level !== 'page') {
+        return label;
+    }
+    const index = (pages ?? []).findIndex((page) => page.id === group.pageId);
+    if (index < 0) {
+        return label;
+    }
+    return `${label} (page "${pages[index].name || `Page ${index + 1}`}")`;
+}
+// The Default period select's choices: Fixed dates, then every relative
+// range in the server enum's order, named by `labels`. A stored range this
+// viewer does not know is listed last, so the select still shows it.
+export function defaultPeriodOptions(labels, stored = null) {
+    const options = [
+        { value: FIXED_DATES_PERIOD, name: 'Fixed dates' },
+        ...RELATIVE_RANGE_NAMES.map((relative) => ({ value: relative, name: labels(relative) })),
+    ];
+    return stored && stored !== FIXED_DATES_PERIOD && !isRelativeRange(stored)
+        ? [...options, { value: stored, name: labels(stored) }]
+        : options;
+}
+// The Default period a stored date range default opens on: its relative
+// range, else Fixed dates (the days, or none).
+export function defaultPeriod(stored) {
+    return stored?.relative && !stored.start && !stored.end
+        ? stored.relative
+        : FIXED_DATES_PERIOD;
+}
+// A date range default in its stored shape: the relative range picked, else
+// the fixed days, or null when there are none. Never both: the server
+// refuses a relative range with days.
+export function dateRangeDefault(period, start, end) {
+    if (period !== FIXED_DATES_PERIOD) {
+        return { relative: period };
+    }
+    if (!start && !end) {
+        return null;
+    }
+    return { ...(start ? { start } : {}), ...(end ? { end } : {}) };
+}
+// A select default in its stored shape: the picks kept, or left out while
+// Exclude these values is on, or null when nothing is picked.
+export function selectDefault(values, exclude) {
+    if (!values.length) {
+        return null;
+    }
+    return exclude ? { excludeValues: values } : { values };
+}
+// A number range default in its stored shape from the ends as typed: an
+// open end is left out, 0 is kept, and two open ends are no default.
+export function numberRangeDefault(rawMin, rawMax) {
+    const min = parseDefaultBound(rawMin);
+    const max = parseDefaultBound(rawMax);
+    if (min === null && max === null) {
+        return null;
+    }
+    return { ...(min !== null ? { min } : {}), ...(max !== null ? { max } : {}) };
+}
+// Whether a select group's default row offers Exclude these values: the
+// report bar's rule (offersExclude), so not on a server that does not serve
+// exclude (an older server lists no features) nor on a group with a member
+// that binds several columns (multiColumn). A default that already leaves
+// values out keeps the toggle, so it can be turned off.
+export function showExcludeToggle(group, features) {
+    if (group.type === 'select' && group.config?.default?.excludeValues?.length) {
+        return true;
+    }
+    return offersExclude(group, features);
+}
+// A stored or draft default in a stable form for comparing: empty and
+// absent keys are dropped, so a no-op edit does not read as a change. 0 is an
+// end like any other. Nothing left is null.
+export function normalizeDefault(value) {
+    if (!value) {
+        return null;
+    }
+    const normalized = {};
+    if (value.start) {
+        normalized.start = value.start;
+    }
+    if (value.end) {
+        normalized.end = value.end;
+    }
+    if (value.values?.length) {
+        normalized.values = value.values;
+    }
+    if (value.excludeValues?.length) {
+        normalized.excludeValues = value.excludeValues;
+    }
+    if (typeof value.min === 'number') {
+        normalized.min = value.min;
+    }
+    if (typeof value.max === 'number') {
+        normalized.max = value.max;
+    }
+    if (value.value) {
+        normalized.value = value.value;
+    }
+    if (value.relative) {
+        normalized.relative = value.relative;
+    }
+    return Object.keys(normalized).length ? normalized : null;
+}
+// Whether a row's draft default differs from the group's stored one. Only a
+// changed row is saved.
+export function defaultChanged(stored, draft) {
+    return JSON.stringify(normalizeDefault(stored)) !== JSON.stringify(normalizeDefault(draft));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-settings-rules.js","sourceRoot":"","sources":["../../../../src/app/reports/filter-settings-rules.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAGzD,qEAAqE;AACrE,MAAM,CAAC,MAAM,mBAAmB,GAA6C;IAC3E,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE;IACnC,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,cAAc,EAAE;CAC/C,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,uCAAuC,CAAC;AAC3E,MAAM,CAAC,MAAM,mBAAmB,GAAG,2CAA2C,CAAC;AAC/E,MAAM,CAAC,MAAM,wBAAwB,GAAG,wBAAwB,CAAC;AAEjE,2EAA2E;AAC3E,uBAAuB;AACvB,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAE1C,gEAAgE;AAChE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAErC,6EAA6E;AAC7E,2EAA2E;AAC3E,wEAAwE;AACxE,MAAM,CAAC,MAAM,mBAAmB,GAAG,wBAAwB,CAAC;AAC5D,MAAM,CAAC,MAAM,2BAA2B,GAAG,gEAAgE,CAAC;AAC5G,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AACzC,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C,+DAA+D;AAC/D,MAAM,qBAAqB,GAA+C;IACxE,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;IAC7B,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE;IACtC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,EAAE;CAC1C,CAAC;AAGF,kEAAkE;AAClE,MAAM,eAAe,GAAG,8BAA8B,CAAC;AACvD,0EAA0E;AAC1E,uEAAuE;AACvE,MAAM,aAAa,GAAG,yBAAyB,CAAC;AAEhD,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,8BAA8B;AAC9B,MAAM,UAAU,iBAAiB,CAAC,GAAY;IAC5C,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3C,CAAC;IAED,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC3B,MAAM,IAAI,GAAG,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IACjF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3B,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/C,CAAC;AAED,8EAA8E;AAC9E,sBAAsB;AACtB,MAAM,UAAU,WAAW,CAAC,GAAkB,EAAE,GAAkB;IAChE,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,EAAE,CAAC;QAC/C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,QAAQ,GAAG,mBAAmB,GAAG,IAAI,CAAC;AAC/C,CAAC;AAED,yEAAyE;AACzE,0EAA0E;AAC1E,6EAA6E;AAC7E,mEAAmE;AACnE,MAAM,UAAU,eAAe,CAC7B,KAA4C,EAC5C,wBAAiC,EACjC,QAAkD;IAElD,MAAM,IAAI,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC;WAChD,mBAAmB,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAEjF,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACzD,CAAC;IAED,OAAO;QACL,IAAI,EAAE,IAAI;QACV,QAAQ,EAAE,wBAAwB;QAClC,OAAO,EAAE,wBAAwB,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,IAAI;KAC/D,CAAC;AACJ,CAAC;AAED,2EAA2E;AAC3E,uEAAuE;AACvE,6CAA6C;AAC7C,MAAM,UAAU,kBAAkB,CAChC,QAAkD,EAClD,MAAe;IAEf,MAAM,MAAM,GAAwB,CAAC,WAAW,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;IAEpE,OAAO,MAAM,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;QACrD,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,MAAM,CAAC;QACrB,CAAC,CAAC,MAAM,CAAC;AACb,CAAC;AAED,4EAA4E;AAC5E,mEAAmE;AACnE,MAAM,UAAU,mBAAmB,CACjC,YAAiC,EACjC,UAA8B,KAAK;IAEnC,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE;QAC7C,QAAQ,MAAM,CAAC,KAAK,EAAE,CAAC;YACrB,KAAK,OAAO;gBACV,OAAO,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,OAAO,KAAK,OAAO,CAAC;YACjG,KAAK,MAAM;gBACT,OAAO,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,OAAO,KAAK,MAAM,CAAC;YAC7D;gBACE,OAAO,IAAI,CAAC;QAChB,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED,wEAAwE;AACxE,2EAA2E;AAC3E,4EAA4E;AAC5E,kEAAkE;AAClE,MAAM,UAAU,qBAAqB,CACnC,YAAiC,EACjC,OAA6C;IAE7C,MAAM,OAAO,GAAG,CAAC,OAAO,IAAI,OAAO,KAAK,MAAM;QAC5C,CAAC,CAAC,YAAY;QACd,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,MAAM,CAAC,CAAC;IAErD,OAAO,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AAC7D,CAAC;AAED,4EAA4E;AAC5E,6EAA6E;AAC7E,8EAA8E;AAC9E,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,UAAU,gBAAgB,CAC9B,SAA6B,EAC7B,OAA6C;IAE7C,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC;IAClD,CAAC;IAED,IAAI,SAAS,KAAK,OAAO,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,WAAW;YACd,OAAO,MAAM,CAAC;QAChB,KAAK,MAAM;YACT,OAAO,QAAQ,CAAC;QAClB;YACE,OAAO,OAAO,CAAC;IACnB,CAAC;AACH,CAAC;AAED,4EAA4E;AAC5E,OAAO;AACP,MAAM,UAAU,YAAY,CAAC,KAA2C;IACtE,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,QAAQ,CAAC;QACd,KAAK,MAAM;YACT,OAAO,OAAO,CAAC;QACjB,KAAK,MAAM;YACT,OAAO,MAAM,CAAC;QAChB;YACE,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,gBAAgB,CAAC,KAA2C;IAC1E,OAAO,KAAK,KAAK,WAAW,IAAI,KAAK,KAAK,MAAM,CAAC;AACnD,CAAC;AAED,4EAA4E;AAC5E,0EAA0E;AAC1E,0CAA0C;AAC1C,MAAM,UAAU,WAAW,CAAC,SAA6B,EAAE,SAAkB;IAC3E,QAAQ,SAAS,EAAE,CAAC;QAClB,KAAK,MAAM;YACT,OAAO,MAAM,CAAC;QAChB,KAAK,OAAO;YACV,OAAO,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC;QACvC;YACE,OAAO,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1C,CAAC;AACH,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,oBAAoB,CAAC,SAA6B;IAChE,OAAO,SAAS,KAAK,MAAM;QACzB,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,mBAAmB,EAAE;QAClD,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,wBAAwB,EAAE,CAAC;AAC7D,CAAC;AAED,2EAA2E;AAC3E,mDAAmD;AACnD,MAAM,UAAU,gBAAgB,CAAC,MAA8C;IAC7E,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC;SAClB,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,CAAC;SAC/F,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;AACvC,CAAC;AAED,oEAAoE;AACpE,6EAA6E;AAC7E,mDAAmD;AACnD,MAAM,UAAU,eAAe,CAAC,KAAwB,EAAE,KAAsC;IAC9F,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,IAAI,QAAQ,CAAC;IAE1E,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1E,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,GAAG,KAAK,WAAW,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI,QAAQ,KAAK,GAAG,CAAC,EAAE,IAAI,CAAC;AACzE,CAAC;AAED,wEAAwE;AACxE,2EAA2E;AAC3E,qEAAqE;AACrE,MAAM,UAAU,oBAAoB,CAClC,MAAiD,EACjD,SAAwB,IAAI;IAE5B,MAAM,OAAO,GAA2B;QACtC,EAAE,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,aAAa,EAAE;QAClD,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;KACzF,CAAC;IAEF,OAAO,MAAM,IAAI,MAAM,KAAK,kBAAkB,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;QACxE,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAA6B,CAAC,EAAE,CAAC;QAC9E,CAAC,CAAC,OAAO,CAAC;AACd,CAAC;AAED,wEAAwE;AACxE,+CAA+C;AAC/C,MAAM,UAAU,aAAa,CAAC,MAA6C;IACzE,OAAO,MAAM,EAAE,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,GAAG;QACrD,CAAC,CAAC,MAAM,CAAC,QAAQ;QACjB,CAAC,CAAC,kBAAkB,CAAC;AACzB,CAAC;AAED,4EAA4E;AAC5E,sEAAsE;AACtE,sCAAsC;AACtC,MAAM,UAAU,gBAAgB,CAC9B,MAAc,EACd,KAAoB,EACpB,GAAkB;IAElB,IAAI,MAAM,KAAK,kBAAkB,EAAE,CAAC;QAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC9B,CAAC;IAED,IAAI,CAAC,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AAClE,CAAC;AAED,0EAA0E;AAC1E,8DAA8D;AAC9D,MAAM,UAAU,aAAa,CAAC,MAAiB,EAAE,OAAgB;IAC/D,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;AAC1D,CAAC;AAED,wEAAwE;AACxE,qEAAqE;AACrE,MAAM,UAAU,kBAAkB,CAAC,MAAe,EAAE,MAAe;IACjE,MAAM,GAAG,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,GAAG,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAEtC,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,GAAG,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AAChF,CAAC;AAED,wEAAwE;AACxE,4EAA4E;AAC5E,2EAA2E;AAC3E,0EAA0E;AAC1E,wDAAwD;AACxD,MAAM,UAAU,iBAAiB,CAC/B,KAAwB,EACxB,QAAkD;IAElD,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,CAAC;QAC5E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AACxC,CAAC;AAED,sEAAsE;AACtE,8EAA8E;AAC9E,4CAA4C;AAC5C,MAAM,UAAU,gBAAgB,CAAC,KAA4C;IAC3E,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,UAAU,GAAuB,EAAE,CAAC;IAC1C,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,UAAU,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IACjC,CAAC;IACD,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;QACd,UAAU,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;IAC7B,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QACzB,UAAU,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IACnC,CAAC;IACD,IAAI,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;QAChC,UAAU,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;IACjD,CAAC;IACD,IAAI,OAAO,KAAK,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;QAClC,UAAU,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;IAC7B,CAAC;IACD,IAAI,OAAO,KAAK,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;QAClC,UAAU,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;IAC7B,CAAC;IACD,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,UAAU,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IACjC,CAAC;IACD,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACnB,UAAU,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IACvC,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC;AAC5D,CAAC;AAED,4EAA4E;AAC5E,wBAAwB;AACxB,MAAM,UAAU,cAAc,CAC5B,MAA6C,EAC7C,KAA4C;IAE5C,OAAO,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9F,CAAC","sourcesContent":["// The rules behind the two filter settings dialogs, kept pure so the node\n// harness checks them without a dialog. The component settings' Filters tab\n// reads the Type select, the Report bar select and the This component toggle\n// from here; the report settings' Filters tab reads its default rows (the\n// period, the exclude toggle, the number range ends and their check) from\n// here. The dialogs only call these.\nimport { FilterBarPlacement } from './interfaces/filter-bar-placement.type';\nimport { FilterComponentToggleState } from './interfaces/filter-component-toggle-state.interface';\nimport { FilterSettingsOption } from './interfaces/filter-settings-option.interface';\nimport { FilterTypeSelectState } from './interfaces/filter-type-select-state.interface';\nimport { ReportViewerFeature } from './interfaces/report-viewer-feature.type';\nimport {\n  FilterGroupDefault,\n  ReportFilterGroup,\n  ReportFilterLevel,\n  ReportFilterType,\n  ReportPage,\n  ReportRelativeRange,\n} from './interfaces/report.interface';\nimport { RELATIVE_RANGE_NAMES, isRelativeRange } from './report-view-config';\nimport { offersExclude } from './report-viewer-features';\n\n\n// The Type select's choices. A column that can be either holds both.\nexport const FILTER_TYPE_OPTIONS: FilterSettingsOption<ReportFilterType>[] = [\n  { value: 'select', name: 'Values' },\n  { value: 'numberRange', name: 'Number range' },\n];\n\nexport const TYPE_LOCKED_TOOLTIP = 'Remove the filter to change its type.';\nexport const PAGE_FILTER_TOOLTIP = 'A page filter shows in the page bar only.';\nexport const COMPONENT_TOGGLE_TOOLTIP = 'Show on this component';\n\n// The Default period select's value for a range of fixed days. No relative\n// range is named this.\nexport const FIXED_DATES_PERIOD = 'fixed';\n\n// How many decimals a Default minimum or Default maximum takes.\nexport const DEFAULT_BOUND_SCALE = 6;\n\n// A filter's Name and Label, checked as the server checks them, so a bad one\n// is caught before Save. The name is an identifier: a letter, then letters\n// and digits. That it is unique in the report is the server's to check.\nexport const FILTER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;\nexport const FILTER_NAME_PATTERN_MESSAGE = 'A name starts with a letter and holds only letters and digits.';\nexport const FILTER_NAME_MAX_LENGTH = 50;\nexport const FILTER_LABEL_MAX_LENGTH = 200;\n\n// Every Report bar choice, in the order the select lists them.\nconst BAR_PLACEMENT_OPTIONS: FilterSettingsOption<FilterBarPlacement>[] = [\n  { value: 'off', name: 'Off' },\n  { value: 'every', name: 'Every page' },\n  { value: 'page', name: 'This page only' },\n];\n\n\n// A number with its group commas in place ('1,250.5', '-12,000').\nconst GROUPED_DECIMAL = /^-?\\d{1,3}(,\\d{3})+(\\.\\d*)?$/;\n// A plain decimal number ('1250.5', '-3', '0', '.5'). Hex, binary, octal,\n// exponents and inner spaces do not match, though Number() reads some.\nconst PLAIN_DECIMAL = /^-?(\\d+(\\.\\d*)?|\\.\\d+)$/;\n\n// A default range end as typed. An empty field is no end. A number input\n// with a mask hands back text with its group commas ('1,250.5'), so those go\n// before Number() reads it; 0 is an end like any other. Anything that is not\n// a decimal number is no end.\nexport function parseDefaultBound(raw: unknown): number | null {\n  if (typeof raw === 'number') {\n    return Number.isFinite(raw) ? raw : null;\n  }\n\n  if (typeof raw !== 'string') {\n    return null;\n  }\n\n  const trimmed = raw.trim();\n  const text = GROUPED_DECIMAL.test(trimmed) ? trimmed.replace(/,/g, '') : trimmed;\n  if (!PLAIN_DECIMAL.test(text)) {\n    return null;\n  }\n\n  const value = Number(text);\n\n  return Number.isFinite(value) ? value : null;\n}\n\n// Why two range ends cannot be saved, in the server's words, or null. An open\n// end is always fine.\nexport function boundsError(min: number | null, max: number | null): string | null {\n  if (min === null || max === null || min <= max) {\n    return null;\n  }\n\n  return `min (${min}) is above max (${max}).`;\n}\n\n// The Type select of a column on the component settings' Filters tab. It\n// shows when the column can take either type and the server serves number\n// ranges (an older server lists no features). A filter's type cannot change,\n// so it is locked while the column has a filter on this component.\nexport function typeSelectState(\n  types: ReportFilterType[] | null | undefined,\n  hasFilterOnThisComponent: boolean,\n  features: ReportViewerFeature[] | null | undefined,\n): FilterTypeSelectState {\n  const show = (features ?? []).includes('numberRange')\n    && FILTER_TYPE_OPTIONS.every((option) => (types ?? []).includes(option.value));\n\n  if (!show) {\n    return { show: false, disabled: false, tooltip: null };\n  }\n\n  return {\n    show: true,\n    disabled: hasFilterOnThisComponent,\n    tooltip: hasFilterOnThisComponent ? TYPE_LOCKED_TOOLTIP : null,\n  };\n}\n\n// The levels a new or moved filter can take on a component. This page only\n// needs a server that serves page filters and a component on a page (a\n// header or footer component is on no page).\nexport function filterLevelChoices(\n  features: ReportViewerFeature[] | null | undefined,\n  onPage: boolean,\n): ReportFilterLevel[] {\n  const levels: ReportFilterLevel[] = ['component', 'report', 'both'];\n\n  return onPage && (features ?? []).includes('pageScope')\n    ? [...levels, 'page']\n    : levels;\n}\n\n// The Report bar select's choices for the levels on offer. The choice a row\n// already holds is always listed, so the select never shows blank.\nexport function barPlacementOptions(\n  levelChoices: ReportFilterLevel[],\n  current: FilterBarPlacement = 'off',\n): FilterSettingsOption<FilterBarPlacement>[] {\n  return BAR_PLACEMENT_OPTIONS.filter((option) => {\n    switch (option.value) {\n      case 'every':\n        return levelChoices.includes('report') || levelChoices.includes('both') || current === 'every';\n      case 'page':\n        return levelChoices.includes('page') || current === 'page';\n      default:\n        return true;\n    }\n  });\n}\n\n// A value's Report bar choices. A value has no strip of its own and its\n// group may be shared, so a pick never lowers the group (the inline values\n// rule): This page only is offered for a new filter, or for a group that is\n// already a page group, never to move a shared group to one page.\nexport function valuePlacementOptions(\n  levelChoices: ReportFilterLevel[],\n  current: ReportFilterLevel | null | undefined,\n): FilterSettingsOption<FilterBarPlacement>[] {\n  const choices = !current || current === 'page'\n    ? levelChoices\n    : levelChoices.filter((level) => level !== 'page');\n\n  return barPlacementOptions(choices, barPlacement(current));\n}\n\n// The level a value's filter group ends at after a Report bar pick, or null\n// when the value leaves it. Off unlinks this value alone and the group keeps\n// its other members. A new filter takes the pick's level. Every page raises a\n// strip-only group to both, keeping its strips, and a page group to the\n// report bar. Nothing else moves the group, so a value never lowers it.\nexport function valueFilterLevel(\n  placement: FilterBarPlacement,\n  current: ReportFilterLevel | null | undefined,\n): ReportFilterLevel | null {\n  if (placement === 'off') {\n    return null;\n  }\n\n  if (!current) {\n    return placement === 'page' ? 'page' : 'report';\n  }\n\n  if (placement !== 'every') {\n    return current;\n  }\n\n  switch (current) {\n    case 'component':\n      return 'both';\n    case 'page':\n      return 'report';\n    default:\n      return current;\n  }\n}\n\n// Where a group of a level shows in the report bar. No group (no filter) is\n// off.\nexport function barPlacement(level: ReportFilterLevel | null | undefined): FilterBarPlacement {\n  switch (level) {\n    case 'report':\n    case 'both':\n      return 'every';\n    case 'page':\n      return 'page';\n    default:\n      return 'off';\n  }\n}\n\n// Whether a group of a level shows on its components.\nexport function shownOnComponent(level: ReportFilterLevel | null | undefined): boolean {\n  return level === 'component' || level === 'both';\n}\n\n// The level the two controls of a row ask for, or null when they ask for no\n// filter at all. A page filter shows in its page's bar only, so This page\n// only ignores the This component toggle.\nexport function filterLevel(placement: FilterBarPlacement, component: boolean): ReportFilterLevel | null {\n  switch (placement) {\n    case 'page':\n      return 'page';\n    case 'every':\n      return component ? 'both' : 'report';\n    default:\n      return component ? 'component' : null;\n  }\n}\n\n// The This component toggle of a row: locked while This page only is picked.\nexport function componentToggleState(placement: FilterBarPlacement): FilterComponentToggleState {\n  return placement === 'page'\n    ? { disabled: true, tooltip: PAGE_FILTER_TOOLTIP }\n    : { disabled: false, tooltip: COMPONENT_TOGGLE_TOOLTIP };\n}\n\n// The groups the report settings' Filters tab lists defaults for: those of\n// the report bar, every page or one, in bar order.\nexport function defaultRowGroups(groups: ReportFilterGroup[] | null | undefined): ReportFilterGroup[] {\n  return (groups ?? [])\n    .filter((group) => group.level === 'report' || group.level === 'both' || group.level === 'page')\n    .sort((a, b) => a.order - b.order);\n}\n\n// A default row's label: a page group names its page, 'Region (page\n// \"Overview\")'. A page with no name reads as the canvas names it ('Page 2').\n// A page this report no longer holds adds nothing.\nexport function defaultRowLabel(group: ReportFilterGroup, pages: ReportPage[] | null | undefined): string {\n  const label = group.label || group.filters?.[0]?.filterColumn || 'Filter';\n\n  if (group.level !== 'page') {\n    return label;\n  }\n\n  const index = (pages ?? []).findIndex((page) => page.id === group.pageId);\n  if (index < 0) {\n    return label;\n  }\n\n  return `${label} (page \"${pages[index].name || `Page ${index + 1}`}\")`;\n}\n\n// The Default period select's choices: Fixed dates, then every relative\n// range in the server enum's order, named by `labels`. A stored range this\n// viewer does not know is listed last, so the select still shows it.\nexport function defaultPeriodOptions(\n  labels: (relative: ReportRelativeRange) => string,\n  stored: string | null = null,\n): FilterSettingsOption[] {\n  const options: FilterSettingsOption[] = [\n    { value: FIXED_DATES_PERIOD, name: 'Fixed dates' },\n    ...RELATIVE_RANGE_NAMES.map((relative) => ({ value: relative, name: labels(relative) })),\n  ];\n\n  return stored && stored !== FIXED_DATES_PERIOD && !isRelativeRange(stored)\n    ? [...options, { value: stored, name: labels(stored as ReportRelativeRange) }]\n    : options;\n}\n\n// The Default period a stored date range default opens on: its relative\n// range, else Fixed dates (the days, or none).\nexport function defaultPeriod(stored: FilterGroupDefault | null | undefined): string {\n  return stored?.relative && !stored.start && !stored.end\n    ? stored.relative\n    : FIXED_DATES_PERIOD;\n}\n\n// A date range default in its stored shape: the relative range picked, else\n// the fixed days, or null when there are none. Never both: the server\n// refuses a relative range with days.\nexport function dateRangeDefault(\n  period: string,\n  start: string | null,\n  end: string | null,\n): FilterGroupDefault | null {\n  if (period !== FIXED_DATES_PERIOD) {\n    return { relative: period };\n  }\n\n  if (!start && !end) {\n    return null;\n  }\n\n  return { ...(start ? { start } : {}), ...(end ? { end } : {}) };\n}\n\n// A select default in its stored shape: the picks kept, or left out while\n// Exclude these values is on, or null when nothing is picked.\nexport function selectDefault(values: unknown[], exclude: boolean): FilterGroupDefault | null {\n  if (!values.length) {\n    return null;\n  }\n\n  return exclude ? { excludeValues: values } : { values };\n}\n\n// A number range default in its stored shape from the ends as typed: an\n// open end is left out, 0 is kept, and two open ends are no default.\nexport function numberRangeDefault(rawMin: unknown, rawMax: unknown): FilterGroupDefault | null {\n  const min = parseDefaultBound(rawMin);\n  const max = parseDefaultBound(rawMax);\n\n  if (min === null && max === null) {\n    return null;\n  }\n\n  return { ...(min !== null ? { min } : {}), ...(max !== null ? { max } : {}) };\n}\n\n// Whether a select group's default row offers Exclude these values: the\n// report bar's rule (offersExclude), so not on a server that does not serve\n// exclude (an older server lists no features) nor on a group with a member\n// that binds several columns (multiColumn). A default that already leaves\n// values out keeps the toggle, so it can be turned off.\nexport function showExcludeToggle(\n  group: ReportFilterGroup,\n  features: ReportViewerFeature[] | null | undefined,\n): boolean {\n  if (group.type === 'select' && group.config?.default?.excludeValues?.length) {\n    return true;\n  }\n\n  return offersExclude(group, features);\n}\n\n// A stored or draft default in a stable form for comparing: empty and\n// absent keys are dropped, so a no-op edit does not read as a change. 0 is an\n// end like any other. Nothing left is null.\nexport function normalizeDefault(value: FilterGroupDefault | null | undefined): FilterGroupDefault | null {\n  if (!value) {\n    return null;\n  }\n\n  const normalized: FilterGroupDefault = {};\n  if (value.start) {\n    normalized.start = value.start;\n  }\n  if (value.end) {\n    normalized.end = value.end;\n  }\n  if (value.values?.length) {\n    normalized.values = value.values;\n  }\n  if (value.excludeValues?.length) {\n    normalized.excludeValues = value.excludeValues;\n  }\n  if (typeof value.min === 'number') {\n    normalized.min = value.min;\n  }\n  if (typeof value.max === 'number') {\n    normalized.max = value.max;\n  }\n  if (value.value) {\n    normalized.value = value.value;\n  }\n  if (value.relative) {\n    normalized.relative = value.relative;\n  }\n\n  return Object.keys(normalized).length ? normalized : null;\n}\n\n// Whether a row's draft default differs from the group's stored one. Only a\n// changed row is saved.\nexport function defaultChanged(\n  stored: FilterGroupDefault | null | undefined,\n  draft: FilterGroupDefault | null | undefined,\n): boolean {\n  return JSON.stringify(normalizeDefault(stored)) !== JSON.stringify(normalizeDefault(draft));\n}\n"]}