@firestitch/report 18.8.1 → 18.10.0

package/esm2022/app/reports/export/report-text-layout.service.mjs

@@ -0,0 +1,241 @@
+import { ApplicationRef, EnvironmentInjector, Injectable, Injector, afterNextRender, createComponent, inject, } from '@angular/core';
+import { ComponentTextComponent } from '../components/component-text/component-text.component';
+import { PX_PER_INCH } from '../components/report-canvas/report-canvas.component';
+import { componentPaddingCss } from '../layout';
+import { fillTextTokens, parseTable, splitAtTables } from '../text';
+import * as i0 from "@angular/core";
+// How far past the bottom of its box a block may reach and still fit: two
+// pixels, so the rounding of the last line's edge never counts as overflow.
+// The deck keeps a table's row on the same terms.
+export const OVERFLOW_SLACK = 2 / PX_PER_INCH;
+// Where the canvas puts each part of a text block, for the exports. A
+// browser wraps the words and sizes a table's columns by its own layout, which
+// neither jsPDF nor PowerPoint reproduces. So the block is rendered offscreen
+// with the canvas's own component, at the canvas's 96px per inch and unscaled,
+// and the exports place what they draw where it sat: a table at its top, in
+// its column widths and row heights, and the words between tables at theirs.
+// It also tells whether the block runs past the bottom of its box.
+//
+// Provided beside the export services, so the block renders under the same
+// injector the canvas's blocks do.
+export class ReportTextLayoutService {
+    _appRef = inject(ApplicationRef);
+    _environmentInjector = inject(EnvironmentInjector);
+    _injector = inject(Injector);
+    _layouts = new Map();
+    // A block is measured once per size, padding and filled html: an export that
+    // draws it twice, or a second export with the same numbers, reads the same
+    // layout, which nothing changes.
+    async measure(component, tokens) {
+        const html = component.config?.html ?? '';
+        const key = [
+            component.id,
+            component.w,
+            component.h,
+            JSON.stringify(component.config?.padding ?? null),
+            fillTextTokens(html, tokens),
+        ].join('|');
+        let layout = this._layouts.get(key);
+        if (!layout) {
+            layout = this._render(component, html, tokens);
+            this._layouts.set(key, layout);
+            // A measure that failed is tried again next time.
+            layout.catch(() => this._layouts.delete(key));
+        }
+        return layout;
+    }
+    async _render(component, html, tokens) {
+        const text = createComponent(ComponentTextComponent, {
+            environmentInjector: this._environmentInjector,
+            elementInjector: this._injector,
+        });
+        const box = blockBox(component, text.location.nativeElement);
+        try {
+            text.setInput('html', html);
+            text.setInput('tokens', tokens);
+            text.setInput('editing', false);
+            document.body.append(box);
+            await this._rendered(text);
+            // Laid out first, so a font the words ask for is loading by the time
+            // fonts.ready is read.
+            box.getBoundingClientRect();
+            await document.fonts.ready;
+            return measureBlock(text.location.nativeElement.querySelector('.text-content'));
+        }
+        finally {
+            // Destroying the block also takes it off the application.
+            text.destroy();
+            box.remove();
+        }
+    }
+    // The block is rendered by the application's own change detection, as any
+    // view attached to it: its inputs mark it for the next render, which draws
+    // it before the callback runs. Not whenStable(): that also waits out
+    // whatever else the host app has under way (its requests and, under
+    // zone.js, its timers), and never resolves while a timer repeats.
+    _rendered(text) {
+        return new Promise((resolve) => {
+            afterNextRender(() => resolve(), { injector: this._environmentInjector });
+            this._appRef.attachView(text.hostView);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportTextLayoutService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportTextLayoutService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportTextLayoutService, decorators: [{
+            type: Injectable
+        }] });
+// The block's box as the canvas draws it (the component box): its size, a
+// 1px border and the block's padding (componentPaddingCss) around a body the
+// text fills. Fixed far off to the left, and hidden, so it is never seen.
+function blockBox(component, text) {
+    const box = document.createElement('div');
+    const body = document.createElement('div');
+    Object.assign(box.style, {
+        position: 'fixed',
+        left: '-10000px',
+        top: '0',
+        visibility: 'hidden',
+        width: `${component.w * PX_PER_INCH}px`,
+        height: `${component.h * PX_PER_INCH}px`,
+        boxSizing: 'border-box',
+        border: '1px solid transparent',
+        padding: componentPaddingCss(component),
+    });
+    body.style.height = '100%';
+    body.append(text);
+    box.append(body);
+    return box;
+}
+// Split the rendered block at its tables, as textBlocks splits the same html,
+// so the nth segment is the nth text part and the nth table the nth table
+// part. How far the block reaches is the bottom of its last part that draws
+// anything.
+function measureBlock(content) {
+    const box = content.getBoundingClientRect();
+    const parts = splitAtTables(content);
+    const segments = [];
+    const tables = [];
+    let usedHeight = 0;
+    parts.forEach((part, index) => {
+        if (Array.isArray(part)) {
+            const segment = measureSegment(drawnNodes(part, index === parts.length - 1), box);
+            segments.push(segment);
+            usedHeight = segment?.bottom ?? usedHeight;
+        }
+        else {
+            const table = measureTable(part, box);
+            tables.push(table);
+            usedHeight = table.top + table.height;
+        }
+    });
+    const contentHeight = inches(box.height);
+    return {
+        contentWidth: inches(box.width),
+        contentHeight,
+        usedHeight,
+        overflow: usedHeight > contentHeight + OVERFLOW_SLACK,
+        segments,
+        tables,
+    };
+}
+// The nodes of a run between tables that the exports draw. Whitespace between
+// blocks draws nothing anywhere. A blank line at the start of a block is
+// drawn, on the canvas and by textBlocks alike, but textBlocks drops the blank
+// lines at the very end of a block, so they are not measured either: a
+// trailing empty paragraph never makes a block overflow.
+function drawnNodes(nodes, blockEnd) {
+    const skipsLast = blockEnd ? isBlank : isVoid;
+    let start = 0;
+    let end = nodes.length;
+    while (start < end && isVoid(nodes[start])) {
+        start++;
+    }
+    while (end > start && skipsLast(nodes[end - 1])) {
+        end--;
+    }
+    const drawn = nodes.slice(start, end);
+    if (blockEnd && drawn.length) {
+        trimBlankLines(drawn[drawn.length - 1]);
+    }
+    return drawn;
+}
+// Take the blank lines off the end of the block's last node, as textBlocks
+// drops them: the elements that hold no text after its last words, down its
+// last children — the <br>s of <p>b<br><br></p>, a list's empty last item.
+// Whitespace is passed over and left, so a paragraph never turns into an
+// empty one, which the canvas draws as a line. The block is the measure's own
+// copy, thrown away once measured, and nothing above what is taken off moves.
+function trimBlankLines(node) {
+    let child = node.lastChild;
+    while (child && isBlank(child)) {
+        const previous = child.previousSibling;
+        if (!isVoid(child)) {
+            child.remove();
+        }
+        child = previous;
+    }
+    if (child) {
+        trimBlankLines(child);
+    }
+}
+// Whitespace between blocks, or a comment.
+function isVoid(node) {
+    return node.nodeType === Node.TEXT_NODE
+        ? !/[^ \t\n\r\f]/.test(node.textContent ?? '')
+        : node.nodeType !== Node.ELEMENT_NODE;
+}
+// A node that draws no words: whitespace, or an element with no text in it,
+// such as the empty line <p><br></p>.
+function isBlank(node) {
+    return isVoid(node) || !node.textContent;
+}
+// From before its first node to after its last. null for a run that draws
+// nothing.
+function measureSegment(nodes, box) {
+    if (!nodes.length) {
+        return null;
+    }
+    const range = document.createRange();
+    range.setStartBefore(nodes[0]);
+    range.setEndAfter(nodes[nodes.length - 1]);
+    const rect = range.getBoundingClientRect();
+    return { top: inches(rect.top - box.top), bottom: inches(rect.bottom - box.top) };
+}
+function measureTable(table, box) {
+    const rect = table.getBoundingClientRect();
+    return {
+        top: inches(rect.top - box.top),
+        left: inches(rect.left - box.left),
+        width: inches(rect.width),
+        height: inches(rect.height),
+        rowHeights: Array.from(table.rows, (row) => inches(row.getBoundingClientRect().height)),
+        columnWidths: columnWidths(table, rect.width).map(inches),
+    };
+}
+// A grid column is as wide as a cell that spans only it. A column that only
+// spanning cells cross shares what the others leave of the table's width, and
+// all of them are scaled to add up to it exactly. The cells come in the same
+// order as the grid's (parseTable reads the same rows), so the nth cell of a
+// row is the nth cell of that grid row.
+function columnWidths(table, width) {
+    const grid = parseTable(table);
+    const widths = Array.from({ length: grid.columns }, () => null);
+    grid.rows.forEach((row, rowIndex) => row.cells.forEach((cell, cellIndex) => {
+        if (cell.colSpan === 1 && widths[cell.column] === null) {
+            widths[cell.column] = table.rows[rowIndex].cells[cellIndex].getBoundingClientRect().width;
+        }
+    }));
+    const known = widths.filter((value) => value !== null);
+    const share = Math.max(0, width - sum(known)) / Math.max(1, widths.length - known.length);
+    const filled = widths.map((value) => value ?? share);
+    const total = sum(filled);
+    return filled.map((value) => total ? value * width / total : width / filled.length);
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}
+function inches(pixels) {
+    return pixels / PX_PER_INCH;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-text-layout.service.js","sourceRoot":"","sources":["../../../../../src/app/reports/export/report-text-layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef, ComponentRef, EnvironmentInjector, Injectable, Injector, afterNextRender, createComponent, inject,\n} from '@angular/core';\n\nimport { ComponentTextComponent } from '../components/component-text/component-text.component';\nimport { PX_PER_INCH } from '../components/report-canvas/report-canvas.component';\nimport { ReportComponent } from '../interfaces/report.interface';\nimport { componentPaddingCss } from '../layout';\nimport { TextTokenContext, fillTextTokens, parseTable, splitAtTables } from '../text';\n\n\n// Where a stretch of a block's words sits: the top of its first line and the\n// bottom of its last.\nexport interface TextSegmentLayout {\n  top: number;\n  bottom: number;\n}\n\n// Where a table sits in its block, and how tall its rows and how wide its\n// columns are.\nexport interface TextTableLayout {\n  top: number;\n  left: number;\n  width: number;\n  height: number;\n  // A row's height, in the order textBlocks lists the rows: the head first and\n  // the foot last.\n  rowHeights: number[];\n  // A grid column's width (tableGrid), left to right. Together they are the\n  // table's width.\n  columnWidths: number[];\n}\n\n// A text block as the canvas lays it out. Everything is in inches, measured\n// from the top left of the block's content box (inside its padding).\nexport interface TextBlockLayout {\n  contentWidth: number;\n  contentHeight: number;\n  // How far down the block's words and tables reach.\n  usedHeight: number;\n  // They reach past the bottom of the box, where the canvas cuts them off.\n  overflow: boolean;\n  // One per text part of textBlocks, in order: null for a part that draws\n  // nothing.\n  segments: (TextSegmentLayout | null)[];\n  // One per table part of textBlocks, in order.\n  tables: TextTableLayout[];\n}\n\n// How far past the bottom of its box a block may reach and still fit: two\n// pixels, so the rounding of the last line's edge never counts as overflow.\n// The deck keeps a table's row on the same terms.\nexport const OVERFLOW_SLACK = 2 / PX_PER_INCH;\n\n// Where the canvas puts each part of a text block, for the exports. A\n// browser wraps the words and sizes a table's columns by its own layout, which\n// neither jsPDF nor PowerPoint reproduces. So the block is rendered offscreen\n// with the canvas's own component, at the canvas's 96px per inch and unscaled,\n// and the exports place what they draw where it sat: a table at its top, in\n// its column widths and row heights, and the words between tables at theirs.\n// It also tells whether the block runs past the bottom of its box.\n//\n// Provided beside the export services, so the block renders under the same\n// injector the canvas's blocks do.\n@Injectable()\nexport class ReportTextLayoutService {\n\n  private readonly _appRef = inject(ApplicationRef);\n  private readonly _environmentInjector = inject(EnvironmentInjector);\n  private readonly _injector = inject(Injector);\n  private readonly _layouts = new Map<string, Promise<TextBlockLayout>>();\n\n  // A block is measured once per size, padding and filled html: an export that\n  // draws it twice, or a second export with the same numbers, reads the same\n  // layout, which nothing changes.\n  public async measure(component: ReportComponent, tokens: TextTokenContext): Promise<TextBlockLayout> {\n    const html = component.config?.html ?? '';\n    const key = [\n      component.id,\n      component.w,\n      component.h,\n      JSON.stringify(component.config?.padding ?? null),\n      fillTextTokens(html, tokens),\n    ].join('|');\n\n    let layout = this._layouts.get(key);\n    if (!layout) {\n      layout = this._render(component, html, tokens);\n      this._layouts.set(key, layout);\n      // A measure that failed is tried again next time.\n      layout.catch(() => this._layouts.delete(key));\n    }\n\n    return layout;\n  }\n\n  private async _render(component: ReportComponent, html: string, tokens: TextTokenContext): Promise<TextBlockLayout> {\n    const text = createComponent(ComponentTextComponent, {\n      environmentInjector: this._environmentInjector,\n      elementInjector: this._injector,\n    });\n    const box = blockBox(component, text.location.nativeElement);\n\n    try {\n      text.setInput('html', html);\n      text.setInput('tokens', tokens);\n      text.setInput('editing', false);\n      document.body.append(box);\n      await this._rendered(text);\n      // Laid out first, so a font the words ask for is loading by the time\n      // fonts.ready is read.\n      box.getBoundingClientRect();\n      await document.fonts.ready;\n\n      return measureBlock(text.location.nativeElement.querySelector('.text-content'));\n    } finally {\n      // Destroying the block also takes it off the application.\n      text.destroy();\n      box.remove();\n    }\n  }\n\n  // The block is rendered by the application's own change detection, as any\n  // view attached to it: its inputs mark it for the next render, which draws\n  // it before the callback runs. Not whenStable(): that also waits out\n  // whatever else the host app has under way (its requests and, under\n  // zone.js, its timers), and never resolves while a timer repeats.\n  private _rendered(text: ComponentRef<ComponentTextComponent>): Promise<void> {\n    return new Promise((resolve) => {\n      afterNextRender(() => resolve(), { injector: this._environmentInjector });\n      this._appRef.attachView(text.hostView);\n    });\n  }\n}\n\n// The block's box as the canvas draws it (the component box): its size, a\n// 1px border and the block's padding (componentPaddingCss) around a body the\n// text fills. Fixed far off to the left, and hidden, so it is never seen.\nfunction blockBox(component: ReportComponent, text: HTMLElement): HTMLElement {\n  const box = document.createElement('div');\n  const body = document.createElement('div');\n\n  Object.assign(box.style, {\n    position: 'fixed',\n    left: '-10000px',\n    top: '0',\n    visibility: 'hidden',\n    width: `${component.w * PX_PER_INCH}px`,\n    height: `${component.h * PX_PER_INCH}px`,\n    boxSizing: 'border-box',\n    border: '1px solid transparent',\n    padding: componentPaddingCss(component),\n  });\n  body.style.height = '100%';\n  body.append(text);\n  box.append(body);\n\n  return box;\n}\n\n// Split the rendered block at its tables, as textBlocks splits the same html,\n// so the nth segment is the nth text part and the nth table the nth table\n// part. How far the block reaches is the bottom of its last part that draws\n// anything.\nfunction measureBlock(content: HTMLElement): TextBlockLayout {\n  const box = content.getBoundingClientRect();\n  const parts = splitAtTables(content);\n  const segments: (TextSegmentLayout | null)[] = [];\n  const tables: TextTableLayout[] = [];\n  let usedHeight = 0;\n\n  parts.forEach((part, index) => {\n    if (Array.isArray(part)) {\n      const segment = measureSegment(drawnNodes(part, index === parts.length - 1), box);\n      segments.push(segment);\n      usedHeight = segment?.bottom ?? usedHeight;\n    } else {\n      const table = measureTable(part, box);\n      tables.push(table);\n      usedHeight = table.top + table.height;\n    }\n  });\n\n  const contentHeight = inches(box.height);\n\n  return {\n    contentWidth: inches(box.width),\n    contentHeight,\n    usedHeight,\n    overflow: usedHeight > contentHeight + OVERFLOW_SLACK,\n    segments,\n    tables,\n  };\n}\n\n// The nodes of a run between tables that the exports draw. Whitespace between\n// blocks draws nothing anywhere. A blank line at the start of a block is\n// drawn, on the canvas and by textBlocks alike, but textBlocks drops the blank\n// lines at the very end of a block, so they are not measured either: a\n// trailing empty paragraph never makes a block overflow.\nfunction drawnNodes(nodes: Node[], blockEnd: boolean): Node[] {\n  const skipsLast = blockEnd ? isBlank : isVoid;\n  let start = 0;\n  let end = nodes.length;\n\n  while (start < end && isVoid(nodes[start])) {\n    start++;\n  }\n  while (end > start && skipsLast(nodes[end - 1])) {\n    end--;\n  }\n\n  const drawn = nodes.slice(start, end);\n  if (blockEnd && drawn.length) {\n    trimBlankLines(drawn[drawn.length - 1]);\n  }\n\n  return drawn;\n}\n\n// Take the blank lines off the end of the block's last node, as textBlocks\n// drops them: the elements that hold no text after its last words, down its\n// last children — the <br>s of <p>b<br><br></p>, a list's empty last item.\n// Whitespace is passed over and left, so a paragraph never turns into an\n// empty one, which the canvas draws as a line. The block is the measure's own\n// copy, thrown away once measured, and nothing above what is taken off moves.\nfunction trimBlankLines(node: Node): void {\n  let child = node.lastChild;\n  while (child && isBlank(child)) {\n    const previous = child.previousSibling;\n    if (!isVoid(child)) {\n      child.remove();\n    }\n    child = previous;\n  }\n\n  if (child) {\n    trimBlankLines(child);\n  }\n}\n\n// Whitespace between blocks, or a comment.\nfunction isVoid(node: Node): boolean {\n  return node.nodeType === Node.TEXT_NODE\n    ? !/[^ \\t\\n\\r\\f]/.test(node.textContent ?? '')\n    : node.nodeType !== Node.ELEMENT_NODE;\n}\n\n// A node that draws no words: whitespace, or an element with no text in it,\n// such as the empty line <p><br></p>.\nfunction isBlank(node: Node): boolean {\n  return isVoid(node) || !node.textContent;\n}\n\n// From before its first node to after its last. null for a run that draws\n// nothing.\nfunction measureSegment(nodes: Node[], box: DOMRect): TextSegmentLayout | null {\n  if (!nodes.length) {\n    return null;\n  }\n\n  const range = document.createRange();\n  range.setStartBefore(nodes[0]);\n  range.setEndAfter(nodes[nodes.length - 1]);\n  const rect = range.getBoundingClientRect();\n\n  return { top: inches(rect.top - box.top), bottom: inches(rect.bottom - box.top) };\n}\n\nfunction measureTable(table: HTMLTableElement, box: DOMRect): TextTableLayout {\n  const rect = table.getBoundingClientRect();\n\n  return {\n    top: inches(rect.top - box.top),\n    left: inches(rect.left - box.left),\n    width: inches(rect.width),\n    height: inches(rect.height),\n    rowHeights: Array.from(table.rows, (row) => inches(row.getBoundingClientRect().height)),\n    columnWidths: columnWidths(table, rect.width).map(inches),\n  };\n}\n\n// A grid column is as wide as a cell that spans only it. A column that only\n// spanning cells cross shares what the others leave of the table's width, and\n// all of them are scaled to add up to it exactly. The cells come in the same\n// order as the grid's (parseTable reads the same rows), so the nth cell of a\n// row is the nth cell of that grid row.\nfunction columnWidths(table: HTMLTableElement, width: number): number[] {\n  const grid = parseTable(table);\n  const widths: (number | null)[] = Array.from({ length: grid.columns }, () => null);\n\n  grid.rows.forEach((row, rowIndex) => row.cells.forEach((cell, cellIndex) => {\n    if (cell.colSpan === 1 && widths[cell.column] === null) {\n      widths[cell.column] = table.rows[rowIndex].cells[cellIndex].getBoundingClientRect().width;\n    }\n  }));\n\n  const known = widths.filter((value): value is number => value !== null);\n  const share = Math.max(0, width - sum(known)) / Math.max(1, widths.length - known.length);\n  const filled = widths.map((value) => value ?? share);\n  const total = sum(filled);\n\n  return filled.map((value) => total ? value * width / total : width / filled.length);\n}\n\nfunction sum(values: number[]): number {\n  return values.reduce((total, value) => total + value, 0);\n}\n\nfunction inches(pixels: number): number {\n  return pixels / PX_PER_INCH;\n}\n"]}

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

@@ -0,0 +1,283 @@
+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;
+// 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":"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","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// 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"]}