@firestitch/report 18.9.0 → 18.10.0

package/esm2022/app/reports/report-url-state.mjs

@@ -1,64 +1,247 @@
-import { GROUP_BY_ITEM, GROUP_PARAM_PREFIX, dateBoundString, dateFromBound, groupItemName, } from './report-filter-items';
-// The report viewer's state in its URL: a pure codec, with no knowledge of a
-// loaded report. ReportFilterStateService decides WHAT is carried (only values
-// that differ from the authored defaults) and checks what is read back against
-// the report; this file only turns values into query params and back.
+import { iso8601 } from '@firestitch/date';
+import { getExcludeName } from '@firestitch/filter';
+import { parseISO } from 'date-fns';
+import { FORMAT_PARAM, GROUP_BY_ITEM, MATCH_ITEM, PERSONAL_VIEW_PARAM, VIEW_PARAM, dateBoundString, groupParamKeys, itemRangeName, } from './report-filter-items';
+import { DRILL_MAX_DEPTH, GROUP_VALUE_MAX_PICKS, REPORT_VIEW_CONFIG_VERSION, isCalendarDay, isChartGranularity, numberFromText, toStoredGroupValue, } from './report-view-config';
+// The report viewer's state in its URL: a pure codec. It knows the report's
+// filter groups only to name their keys; ReportFilterStateService decides
+// WHAT is carried (only values that differ from the link's base) and checks
+// what is read back against the report; this file only turns values into
+// query params and back. Each value below is as the codec writes it; the
+// router percent-encodes it again in the address bar.
 //
-//   ?page=7&groupBy=week&g12=last30Days&g15=3,5&g16=2026-01-01..&s31=-create_date&q31=north&h31=notes,total
+//   ?page=7&groupBy=week&region=3:North,5:East&excludeStatus=2:Refunded
+//    &shippedFrom=2026-01-01T00:00:00-05:00&shippedTo=2026-01-31T00:00:00-05:00
+//    &unitsMin=0&unitsMax=50&s31=-create_date&q31=north
+//    &h31=notes,total&d44=year:2026-01-01,quarter:2026-07-01&match=any&rv=12&rf=2
 //
-// - g<groupId>: one key per filter group. A dateRange is its relative preset
-//   name when it carries one, else 'YYYY-MM-DD..YYYY-MM-DD' (either side may be
-//   empty); a select is its values joined by ','; a keyword is its text. An
-//   empty value is an explicit clear of a group that has a default.
+// A filter group is written under its fs-filter item's own query keys, so
+// the bar and the link have one syntax. <key> is the group's key, the
+// camelCase of its label ('Region' -> region; groupParamKeys in
+// report-filter-items.ts, which also says what a clash falls back to:
+// region12).
+// - A select: <key>=value:name,... for the values it keeps and
+//   exclude<Key>=value:name,... for the values it leaves out. This is
+//   fs-filter's own syntax: ',' between picks, ':' between a value and its
+//   name, and a ',', ':' or '\' inside either one escaped with '\'. The name
+//   is the one the chip showed when the link was written, and is left off
+//   while the viewer has not seen it. Only the value is read back: names come
+//   from the option list, so a renamed option shows its new name.
+// - A number range: <key>Min and <key>Max, either one open.
+// - A date range: <key>From and <key>To in fs-filter's date format (the
+//   day's local midnight with its offset, 2026-01-01T00:00:00-05:00), either
+//   one open. Only the day is read back, so a link opens on the same days in
+//   every zone. A link never names a preset: a date picker preset only sets
+//   the days, and a rolling range (a report's relative default) is not written
+//   while it is the link's base, and is written as its days when it must be
+//   (the caller turns it into days first; see groupValueParams).
+// - A keyword: <key>=text.
+// An empty value is an explicit clear of a group that has a default: <key>=
+// for a select or a keyword, both ends empty for a range.
+// The other keys:
 // - s<componentId>: a list's sort column, '-' prefixed when descending.
 // - q<componentId>: the text in a list's search box.
 // - h<componentId>: the columns a viewer hid on a list (encodeColumnList).
+// - d<componentId>: a chart's drill path, 'level:value' steps (each part
+//   percent-encoded) joined by ','.
 // - groupBy: the group-by grain (GROUP_BY_ITEM).
+// - match=any: the groups combine with any (absent = all).
+// - rv: the shared view the state is a diff from. rpv: the open personal
+//   view, a label only, never a base.
+// - rf=2: the format every link this viewer writes carries.
+// A key this codec does not know is ignored and left in the URL as it is.
 // The page key is the host's (FsAiReportComponent.pageQueryParam) and is
-// written beside these, never by this codec.
-// The prefix of a group's value key. Declared beside the filter items, which
-// read it too (declaring it here would make the two files import each other);
-// re-exported so every codec constant can be imported from the codec.
-export { GROUP_PARAM_PREFIX } from './report-filter-items';
+// written beside these, never by this codec. The cross-filter and the rows
+// panel are never in the URL.
+//
+// The keys the codec owns: the tile keys, groupBy, match, rv, rpv, rf, and
+// every key a group of the open report is written under. A write removes an
+// owned key it no longer carries, so a host must not keep its own state
+// under one. A group key comes from a label, so a host param named like one
+// (a group labeled 'Status' owns status and excludeStatus) is the codec's.
+// Only the default page key, 'page', is kept off the groups.
+// The keys of the views and the format. Declared beside the filter items,
+// which keep a group key off them (declaring them here would make the two
+// files import each other); re-exported so every codec constant can be
+// imported from the codec.
+export { FORMAT_PARAM, PERSONAL_VIEW_PARAM, VIEW_PARAM } from './report-filter-items';
 // The prefix of a list's sort key.
 export const LIST_SORT_PARAM_PREFIX = 's';
-// Between the two days of an encoded fixed date range.
-export const DATE_RANGE_SEPARATOR = '..';
 // The prefix of a list's search key.
 export const LIST_SEARCH_PARAM_PREFIX = 'q';
 // The prefix of a list's hidden-columns key.
 export const LIST_HIDDEN_PARAM_PREFIX = 'h';
-// The prefixes of the keys this codec owns, each followed by an id.
-const OWNED_PREFIXES = [
-    GROUP_PARAM_PREFIX, LIST_SORT_PARAM_PREFIX, LIST_SEARCH_PARAM_PREFIX, LIST_HIDDEN_PARAM_PREFIX,
-];
-// A key this codec owns: a group value, or a list's sort, search or hidden
-// columns. Any such key the snapshot no longer carries is removed from the
-// URL, so a host must not keep its own state under a key of this shape (one
-// of the prefixes above, then digits).
-export const OWNED_PARAM = new RegExp(`^[${OWNED_PREFIXES.join('')}]\\d+$`);
-const DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-// The viewer-state params of a URL as raw strings. Keys this codec does not
-// own are ignored.
-export function readReportUrlParams(params) {
-    const groups = new Map();
+// The prefix of a chart's drill-path key.
+export const DRILL_PARAM_PREFIX = 'd';
+// The match's key: the report bar's Match item's own name.
+export const MATCH_PARAM = MATCH_ITEM;
+// The format a link this viewer writes carries.
+export const URL_FORMAT = 2;
+// Between a drill step's level and its value.
+export const DRILL_STEP_SEPARATOR = ':';
+// Between a select's picks, and between a pick's value and its name
+// (fs-filter's AutoCompleteChips syntax).
+export const PICK_SEPARATOR = ',';
+export const PICK_NAME_SEPARATOR = ':';
+// Before a ',', ':' or '\' that is part of a pick's value or name.
+const PICK_ESCAPE = '\\';
+// The most characters the codec's params may take in a link (the host's own
+// path and params are not counted).
+export const REPORT_URL_MAX_LENGTH = 2000;
+// Shown once when a link left group values out (ReportUrlWrite.tooLong).
+export const URL_TOO_LONG_MESSAGE = 'This filter is too long for a link; save a view to share it.';
+const MATCH_ANY = 'any';
+// The prefixes of the tile keys this codec owns, each followed by an id.
+const OWNED_PREFIXES = [LIST_SORT_PARAM_PREFIX, LIST_SEARCH_PARAM_PREFIX, LIST_HIDDEN_PARAM_PREFIX, DRILL_PARAM_PREFIX];
+// The keys this codec owns that carry no id and do not depend on the report.
+const OWNED_KEYS = [GROUP_BY_ITEM, MATCH_PARAM, VIEW_PARAM, PERSONAL_VIEW_PARAM, FORMAT_PARAM];
+// A key of one of the prefixes above, followed by its id.
+const ID_PARAM = new RegExp(`^([${OWNED_PREFIXES.join('')}])(\\d+)$`);
+// A key this codec owns whatever the report: a list's sort, search or hidden
+// columns; a chart's drill path; the grain, the match, the two views and the
+// format. The groups' keys are owned too (see the top of this file).
+export const OWNED_PARAM = new RegExp(`^(?:[${OWNED_PREFIXES.join('')}]\\d+|${OWNED_KEYS.join('|')})$`);
+// A link's day: 'yyyy-MM-dd', alone or as the start of fs-filter's date
+// format ('T' and a time and offset after it).
+const LINK_DAY = /^(\d{4}-\d{2}-\d{2})(?:T.*)?$/;
+// The viewer-state params of a URL: the groups' values in their stored shape
+// (null for a group the link clears; read as paramsToViewConfig reads them),
+// the rest as raw strings. Keys this codec does not own are ignored.
+// `groups` is every filter group of the report.
+export function readReportUrlParams(params, groups) {
     const listSorts = new Map();
     const listSearches = new Map();
     const listHidden = new Map();
-    // Each owned prefix names the map its keys go to; a prefix with no entry
-    // here is never read as some other kind of state.
+    // Each prefix read here names the map its keys go to; a prefix with no
+    // entry is never read as some other kind of state.
     const byPrefix = {
-        [GROUP_PARAM_PREFIX]: groups,
         [LIST_SORT_PARAM_PREFIX]: listSorts,
         [LIST_SEARCH_PARAM_PREFIX]: listSearches,
         [LIST_HIDDEN_PARAM_PREFIX]: listHidden,
     };
+    const query = {};
     for (const key of params.keys) {
-        if (OWNED_PARAM.test(key)) {
-            byPrefix[key.charAt(0)]?.set(Number(key.slice(1)), params.get(key) ?? '');
+        query[key] = params.get(key) ?? '';
+        const owned = ID_PARAM.exec(key);
+        if (owned) {
+            byPrefix[owned[1]]?.set(Number(owned[2]), params.get(key) ?? '');
+        }
+    }
+    return {
+        groups: readGroupParams(query, groups),
+        listSorts, listSearches, listHidden,
+        groupBy: params.get(GROUP_BY_ITEM),
+    };
+}
+// The viewer state a link carries, as a view config: its group values (read
+// by each group's type, so a group the report does not have is skipped), the
+// grain, the match and each tile's sort, search, hidden columns and drill
+// path. A param that is unusable is left out. Whether a tile's component and
+// a list's columns exist is the caller's check. `groups` is every filter
+// group of the report.
+export function paramsToViewConfig(params, groups) {
+    const config = { v: REPORT_VIEW_CONFIG_VERSION };
+    const groupBy = paramText(params[GROUP_BY_ITEM]);
+    if (isChartGranularity(groupBy)) {
+        config.groupBy = groupBy;
+    }
+    if (paramText(params[MATCH_PARAM]) === MATCH_ANY) {
+        config.match = MATCH_ANY;
+    }
+    readGroupParams(params, groups).forEach((value, groupId) => {
+        config.groups = { ...config.groups, [groupId]: value };
+    });
+    Object.keys(params).forEach((key) => {
+        const owned = ID_PARAM.exec(key);
+        const raw = paramText(params[key]);
+        if (owned && raw !== null) {
+            readTileParam(config, owned[1], Number(owned[2]), raw);
+        }
+    });
+    return config;
+}
+// The params that make a link carry `config`, the views it names, and rf=2.
+// Each group is written under its keys among `groups` (every filter group of
+// the report); a group the report no longer has is left out. `name` names a
+// select's values. Past REPORT_URL_MAX_LENGTH the longest group values are
+// left out (those groups then open at the link's base) and tooLong is set.
+export function viewConfigToParams(config, groups, link = {}, name = () => null) {
+    const params = {};
+    const keys = groupParamKeys(groups);
+    const types = new Map(groups.map((group) => [group.id, group.type]));
+    const groupParams = new Set();
+    if (config.groupBy) {
+        params[GROUP_BY_ITEM] = config.groupBy;
+    }
+    Object.entries(config.groups ?? {}).forEach(([id, value]) => {
+        const groupId = Number(id);
+        const key = keys.get(groupId);
+        if (key) {
+            const written = groupValueParams(types.get(groupId), key, value, (pick) => name(groupId, pick));
+            Object.assign(params, written);
+            Object.keys(written).forEach((param) => groupParams.add(param));
         }
+    });
+    Object.entries(config.tiles ?? {}).forEach(([componentId, tile]) => {
+        Object.assign(params, tileParams(Number(componentId), tile));
+    });
+    if (config.match === MATCH_ANY) {
+        params[MATCH_PARAM] = MATCH_ANY;
+    }
+    if (link.viewId) {
+        params[VIEW_PARAM] = String(link.viewId);
     }
-    return { groups, listSorts, listSearches, listHidden, groupBy: params.get(GROUP_BY_ITEM) };
+    if (link.personalViewId) {
+        params[PERSONAL_VIEW_PARAM] = String(link.personalViewId);
+    }
+    return capReportParams(withFormat(params), groupParams);
+}
+// The views a link names, each a positive id or null.
+export function readReportUrlLink(params) {
+    return {
+        viewId: positiveId(paramText(params[VIEW_PARAM])),
+        personalViewId: positiveId(paramText(params[PERSONAL_VIEW_PARAM])),
+    };
+}
+// Whether a link carries viewer state of its own, so it opens on that state
+// rather than on a default view: any owned key but the format marker and the
+// personal view, which is a label only. `groups` is every filter group of
+// the report.
+export function hasReportUrlState(params, groups) {
+    const groupKeys = ownedGroupKeys(groups);
+    return Object.keys(params).some((key) => ID_PARAM.test(key) || groupKeys.has(key)
+        || key === GROUP_BY_ITEM || key === MATCH_PARAM || key === VIEW_PARAM);
+}
+// Every owned key `current` carries, set to null: under the router's 'merge'
+// handling, a write spread over these removes the keys it no longer carries.
+// Keys this codec does not own are left alone. `groups` is every filter
+// group of the report.
+export function reportParamsToClear(current, groups) {
+    const groupKeys = ownedGroupKeys(groups);
+    const params = {};
+    for (const key of current.keys) {
+        if (OWNED_PARAM.test(key) || groupKeys.has(key)) {
+            params[key] = null;
+        }
+    }
+    return params;
+}
+// The names the select picks in `current` (the URL as it is) carry, so a
+// write can keep a name the viewer's lists have not named yet. Only a write
+// reads these: what the chips show comes from the lists.
+export function urlValueNames(current, groups) {
+    const keys = groupParamKeys(groups);
+    const names = new Map();
+    groups
+        .filter((group) => group.type === 'select')
+        .forEach((group) => {
+        const key = keys.get(group.id);
+        const picks = [current.get(key), current.get(getExcludeName(key))]
+            .flatMap((raw) => (raw ? decodePickList(raw) : []))
+            .filter((pick) => pick.name !== null);
+        names.set(group.id, new Map(picks.map((pick) => [pick.value, pick.name])));
+    });
+    return (groupId, value) => names.get(groupId)?.get(String(value)) ?? null;
 }
 // A list's hidden column names as one param value. A name is a query's output
 // alias, which can hold a comma, so each is percent-encoded before the join.
@@ -71,57 +254,35 @@ export function encodeColumnList(names) {
 export function decodeColumnList(raw) {
     return raw.split(',')
         .filter((item) => item !== '')
-        .map((item) => {
-        try {
-            return decodeURIComponent(item);
-        }
-        catch {
-            return item;
-        }
-    });
+        .map(decodeItem);
 }
-// A group value read back from its URL param. null is an explicit clear (an
-// empty param). undefined means the param is unusable for a group of this type
-// (an unknown preset name, a malformed day, a wrong shape) and is ignored.
-// `resolveRelative` turns a preset name into today's range for it, or null for
-// a name it does not know.
-export function decodeFilterValue(type, raw, resolveRelative) {
-    if (raw === '') {
-        return null;
-    }
-    switch (type) {
-        case 'dateRange':
-            return raw.includes(DATE_RANGE_SEPARATOR)
-                ? decodeFixedRange(raw)
-                : decodePreset(raw, resolveRelative);
-        case 'select': {
-            const values = raw.split(',').filter((value) => value !== '');
-            return values.length ? { values } : undefined;
-        }
-        case 'keyword':
-            return raw.trim() ? { value: raw } : undefined;
-        default:
-            return undefined;
-    }
-}
-// A group value as its URL param. The shape says how: a preset name, then a
-// date range, then select values, then keyword text. null (a cleared group)
-// is the empty param.
-export function encodeFilterValue(value) {
+// A group's value in its stored shape as the link's params under the group's
+// key (see the top of this file): days, then a select's values left out, then
+// its values kept, then a number range, then keyword text. null (a cleared
+// group), or a value that holds nothing, is the group's keys, empty. A
+// relative range with no days is not written at all: a link carries days, and
+// only the caller has the report's zone and clock to give them
+// (ReportViewService). `name` names a select's value.
+export function groupValueParams(type, key, value, name = () => null) {
     if (!value) {
-        return '';
-    }
-    if (value.preset) {
-        return value.preset;
+        return clearParams(type, key);
     }
     if (value.start || value.end) {
-        return [dateBoundString(value.start) ?? '', dateBoundString(value.end) ?? '']
-            .join(DATE_RANGE_SEPARATOR);
+        return rangeParams(type, key, ['from', 'to'], [linkDayText(value.start), linkDayText(value.end)]);
+    }
+    if (value.excludeValues?.length) {
+        return { [getExcludeName(key)]: encodePicks(value.excludeValues, name) };
     }
     if (value.values) {
-        return value.values.map((item) => String(item)).join(',');
+        return { [key]: encodePicks(value.values, name) };
     }
-    return value.value ?? '';
+    if (isNumberEnd(value.min) || isNumberEnd(value.max)) {
+        return rangeParams(type, key, ['min', 'max'], [numberEndText(value.min), numberEndText(value.max)]);
+    }
+    if (value.relative) {
+        return {};
+    }
+    return value.value ? { [key]: value.value } : clearParams(type, key);
 }
 export function encodeSort(sort) {
     return `${sort.direction === 'desc' ? '-' : ''}${sort.column}`;
@@ -135,19 +296,49 @@ export function decodeSort(raw) {
         ? { column, direction: descending ? 'desc' : 'asc' }
         : null;
 }
-// The query params that make the URL carry `snapshot`: every snapshot key is
-// set, and each owned key (or the grain) that `current` carries but the
-// snapshot does not is set to null, which removes it under the router's
-// 'merge' handling. Keys this codec does not own are left alone.
-export function buildReportUrlParams(snapshot, current) {
-    const params = {};
-    for (const key of current.keys) {
-        if (OWNED_PARAM.test(key) || key === GROUP_BY_ITEM) {
-            params[key] = null;
+// A drill path as its URL param. A step with no value writes its level only.
+export function encodeDrillPath(path) {
+    return path
+        .map((step) => (step.value === null || step.value === undefined
+        ? encodeURIComponent(step.level)
+        : `${encodeURIComponent(step.level)}${DRILL_STEP_SEPARATOR}${encodeURIComponent(String(step.value))}`))
+        .join(',');
+}
+// A drill path read back from its URL param: its steps up to the first that
+// is not a time level (the steps before it are kept), at most DRILL_MAX_DEPTH
+// of them. Values come back as text. Whether the path fits the chart is the
+// server's check (it applies the longest valid prefix).
+export function decodeDrillPath(raw) {
+    const path = [];
+    for (const item of raw.split(',')) {
+        const step = decodeDrillStep(item);
+        if (!step || path.length === DRILL_MAX_DEPTH) {
+            break;
         }
+        path.push(step);
     }
+    return path;
+}
+// The query params that make the URL carry `snapshot`: every snapshot key is
+// set, and each owned key that `current` carries but the snapshot does not is
+// set to null, which removes it under the router's 'merge' handling. Keys
+// this codec does not own are left alone. Each group is written under its
+// keys among `groups` (every filter group of the report). A select's value
+// is named by `name`, else by the name `current` carries for it. A date range
+// is written as the days on screen, never as a preset name.
+export function buildReportUrlParams(snapshot, current, groups, name = () => null) {
+    const params = {};
+    const keys = groupParamKeys(groups);
+    const types = new Map(groups.map((group) => [group.id, group.type]));
+    const currentName = urlValueNames(current, groups);
     snapshot.groups.forEach((value, groupId) => {
-        params[groupItemName({ id: groupId })] = encodeFilterValue(value);
+        const key = keys.get(groupId);
+        if (key) {
+            const type = types.get(groupId);
+            const named = (pick) => name(groupId, pick) ?? currentName(groupId, pick);
+            const days = value ? { ...value, preset: undefined } : value;
+            Object.assign(params, groupValueParams(type, key, toStoredGroupValue(type, days), named));
+        }
     });
     snapshot.listSorts.forEach((sort, componentId) => {
         params[`${LIST_SORT_PARAM_PREFIX}${componentId}`] = encodeSort(sort);
@@ -162,28 +353,325 @@ export function buildReportUrlParams(snapshot, current) {
     if (snapshot.frequency) {
         params[GROUP_BY_ITEM] = snapshot.frequency;
     }
-    return params;
+    return { ...reportParamsToClear(current, groups), ...withFormat(params) };
 }
-// 'YYYY-MM-DD..YYYY-MM-DD', either side optional but not both. Each side must
-// be a real calendar day.
-function decodeFixedRange(raw) {
-    const sides = raw.split(DATE_RANGE_SEPARATOR);
-    if (sides.length !== 2 || (!sides[0] && !sides[1])) {
-        return undefined;
+// `params` with the format marker, when it carries anything.
+function withFormat(params) {
+    return Object.keys(params).length ? { ...params, [FORMAT_PARAM]: String(URL_FORMAT) } : params;
+}
+// Each group's value a link carries, in its stored shape, by group id (null
+// for a group the link clears). A group with no usable param is left out.
+function readGroupParams(params, groups) {
+    const keys = groupParamKeys(groups);
+    const values = new Map();
+    for (const group of groups) {
+        const value = readGroupParam(params, group.type, keys.get(group.id));
+        if (value !== undefined) {
+            values.set(group.id, value);
+        }
+    }
+    return values;
+}
+// One group's value in a link, read from the keys of its type. null is a
+// clear; undefined is no usable value.
+function readGroupParam(params, type, key) {
+    switch (type) {
+        case 'select':
+            return readSelect(params, key);
+        case 'dateRange':
+            return readDateRange(params, key);
+        case 'numberRange':
+            return readNumberRange(params, key);
+        case 'keyword':
+            return readKeyword(params[key]);
+        default:
+            return undefined;
+    }
+}
+// A select's values kept (<key>), else its values left out (exclude<Key>).
+function readSelect(params, key) {
+    const kept = paramText(params[key]);
+    if (kept !== null) {
+        return kept === '' ? null : decodePicks(kept, 'values');
+    }
+    const excluded = paramText(params[getExcludeName(key)]);
+    if (excluded !== null) {
+        return excluded === '' ? null : decodePicks(excluded, 'excludeValues');
     }
-    const [start, end] = sides.map((side) => side ? decodeDay(side) : null);
+    return undefined;
+}
+// A date range's days (<key>From, <key>To), each a real calendar day,
+// either one open but not both.
+function readDateRange(params, key) {
+    const ends = readRangeEnds(params, key, ['from', 'to']);
+    if (!ends) {
+        return ends === null ? null : undefined;
+    }
+    const [start, end] = ends.map(linkDay);
     if (start === undefined || end === undefined) {
         return undefined;
     }
-    return { start, end };
+    return compactRange(start, end, 'start', 'end');
+}
+// A number range's ends (<key>Min, <key>Max), each a finite number, either
+// one open but not both, and min not above max.
+function readNumberRange(params, key) {
+    const ends = readRangeEnds(params, key, ['min', 'max']);
+    if (!ends) {
+        return ends === null ? null : undefined;
+    }
+    const [min, max] = ends.map((end) => (end === '' ? null : numberFromText(end)));
+    if ((ends[0] !== '' && min === null) || (ends[1] !== '' && max === null) || (min !== null && max !== null && min > max)) {
+        return undefined;
+    }
+    return compactRange(min, max, 'min', 'max');
+}
+// A keyword's text. Blank text is unusable.
+function readKeyword(raw) {
+    const text = paramText(raw);
+    if (text === null) {
+        return undefined;
+    }
+    if (text === '') {
+        return null;
+    }
+    return text.trim() ? { value: text } : undefined;
 }
-// One side of a fixed range as a local Date, or undefined when it is not a
-// real Y-M-D day.
-function decodeDay(side) {
-    return DAY_PATTERN.test(side) ? (dateFromBound(side) ?? undefined) : undefined;
+// A range's two ends as written ('' for one the link leaves open):
+// undefined when the link carries neither key, null when every one it
+// carries is empty (a clear).
+function readRangeEnds(params, key, ends) {
+    const [low, high] = ends.map((end) => paramText(params[itemRangeName(key, end)]));
+    if (low === null && high === null) {
+        return undefined;
+    }
+    return low || high ? [low ?? '', high ?? ''] : null;
 }
-function decodePreset(name, resolveRelative) {
-    const range = resolveRelative(name);
-    return range ? { start: range.start, end: range.end, preset: name } : undefined;
+// The params of a range's ends, the ones it sets only; with neither one
+// usable, the group's clear.
+function rangeParams(type, key, ends, texts) {
+    const params = {};
+    ends.forEach((end, index) => {
+        if (texts[index]) {
+            params[itemRangeName(key, end)] = texts[index];
+        }
+    });
+    return Object.keys(params).length ? params : clearParams(type, key);
+}
+// The params of a cleared group: its keys, empty.
+function clearParams(type, key) {
+    switch (type) {
+        case 'dateRange':
+            return { [itemRangeName(key, 'from')]: '', [itemRangeName(key, 'to')]: '' };
+        case 'numberRange':
+            return { [itemRangeName(key, 'min')]: '', [itemRangeName(key, 'max')]: '' };
+        default:
+            return { [key]: '' };
+    }
+}
+// A stored day in fs-filter's date format: its local midnight with the
+// offset, '' when there is no real day.
+function linkDayText(bound) {
+    const day = dateBoundString(bound);
+    return day && isCalendarDay(day) ? iso8601(parseISO(day)) : '';
+}
+// The day of a link's date end: null when the end is open (''), undefined
+// when it is not a real calendar day.
+function linkDay(text) {
+    if (text === '') {
+        return null;
+    }
+    const day = LINK_DAY.exec(text)?.[1];
+    return day && isCalendarDay(day) ? day : undefined;
+}
+// The keys a link carries the groups' values under, by each group's type.
+function ownedGroupKeys(groups) {
+    const keys = groupParamKeys(groups);
+    return new Set(groups.flatMap((group) => {
+        const key = keys.get(group.id);
+        switch (group.type) {
+            case 'select':
+                return [key, getExcludeName(key)];
+            case 'dateRange':
+                return [itemRangeName(key, 'from'), itemRangeName(key, 'to')];
+            case 'numberRange':
+                return [itemRangeName(key, 'min'), itemRangeName(key, 'max')];
+            default:
+                return [key];
+        }
+    }));
+}
+// One id-keyed param of a tile read into `config`.
+function readTileParam(config, prefix, id, raw) {
+    switch (prefix) {
+        case LIST_SORT_PARAM_PREFIX:
+            setTileState(config, id, 'sort', decodeSort(raw));
+            break;
+        case LIST_SEARCH_PARAM_PREFIX:
+            setTileState(config, id, 'search', raw || null);
+            break;
+        case LIST_HIDDEN_PARAM_PREFIX:
+            setTileState(config, id, 'hidden', nonEmpty(decodeColumnList(raw)));
+            break;
+        default:
+            setTileState(config, id, 'drill', nonEmpty(decodeDrillPath(raw)));
+    }
+}
+// Sets one key of a tile's state, creating the tile, unless there is nothing
+// to set.
+function setTileState(config, componentId, key, value) {
+    if (value === null) {
+        return;
+    }
+    config.tiles = { ...config.tiles, [componentId]: { ...config.tiles?.[componentId], [key]: value } };
+}
+// The params of one tile's state.
+function tileParams(componentId, tile) {
+    const params = {};
+    if (tile.sort?.column) {
+        params[`${LIST_SORT_PARAM_PREFIX}${componentId}`] = encodeSort(tile.sort);
+    }
+    // The text as typed: the router percent-encodes it in the URL.
+    if (tile.search) {
+        params[`${LIST_SEARCH_PARAM_PREFIX}${componentId}`] = tile.search;
+    }
+    if (tile.hidden?.length) {
+        params[`${LIST_HIDDEN_PARAM_PREFIX}${componentId}`] = encodeColumnList(tile.hidden);
+    }
+    if (tile.drill?.length) {
+        params[`${DRILL_PARAM_PREFIX}${componentId}`] = encodeDrillPath(tile.drill);
+    }
+    return params;
+}
+// `params` within REPORT_URL_MAX_LENGTH: past it, group values (the params
+// named in `groupParams`) are left out, longest first, until the rest fits.
+function capReportParams(params, groupParams) {
+    if (queryLength(params) <= REPORT_URL_MAX_LENGTH) {
+        return { params, tooLong: false };
+    }
+    const kept = { ...params };
+    const groupKeys = Object.keys(kept)
+        .filter((key) => groupParams.has(key))
+        .sort((a, b) => queryText(kept[b]).length - queryText(kept[a]).length);
+    for (const key of groupKeys) {
+        if (queryLength(kept) <= REPORT_URL_MAX_LENGTH) {
+            break;
+        }
+        delete kept[key];
+    }
+    return { params: kept, tooLong: true };
+}
+// The length of `params` as the router writes them in a query string.
+function queryLength(params) {
+    return Object.entries(params)
+        .map(([key, value]) => `${queryText(key)}=${queryText(value)}`)
+        .join('&')
+        .length;
+}
+// Text as the router writes it in a query string (its query encoding):
+// percent-encoded, with '@', ':', '$', ',' and ';' left as they are.
+function queryText(text) {
+    return encodeURIComponent(text)
+        .replace(/%40/g, '@')
+        .replace(/%3A/gi, ':')
+        .replace(/%24/g, '$')
+        .replace(/%2C/gi, ',')
+        .replace(/%3B/gi, ';');
+}
+// A param's text: a repeated key gives its first value.
+function paramText(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    return typeof first === 'string' || typeof first === 'number' ? String(first) : null;
+}
+function positiveId(raw) {
+    return raw !== null && /^[1-9]\d*$/.test(raw) ? Number(raw) : null;
+}
+function nonEmpty(list) {
+    return list.length ? list : null;
+}
+// An item of a list param, percent-decoded; one that does not decode (a
+// hand-edited '%') is kept as written.
+function decodeItem(item) {
+    try {
+        return decodeURIComponent(item);
+    }
+    catch {
+        return item;
+    }
+}
+// Select picks as one param value: value:name for each, the name left off
+// when `name` does not know it, blanks left out.
+function encodePicks(picks, name) {
+    return picks
+        .filter((pick) => typeof pick === 'string' || typeof pick === 'number' || typeof pick === 'boolean')
+        .filter((pick) => String(pick) !== '')
+        .map((pick) => {
+        const named = name(pick);
+        return named ? `${escapePick(String(pick))}${PICK_NAME_SEPARATOR}${escapePick(named)}` : escapePick(String(pick));
+    })
+        .join(PICK_SEPARATOR);
+}
+// A pick's value or name with each ',', ':' and '\' in it escaped.
+function escapePick(text) {
+    return text.replace(/[\\,:]/g, (char) => `${PICK_ESCAPE}${char}`);
+}
+// The picks of a param written as encodePicks writes them, in order: each
+// value and its name (null when the pick has none).
+function decodePickList(raw) {
+    const picks = [];
+    let parts = [''];
+    let escaped = false;
+    const endPick = () => picks.push({ value: parts[0], name: parts.length > 1 ? parts[1] : null });
+    for (const char of raw) {
+        if (escaped) {
+            parts[parts.length - 1] += char;
+            escaped = false;
+        }
+        else if (char === PICK_ESCAPE) {
+            escaped = true;
+        }
+        else if (char === PICK_NAME_SEPARATOR && parts.length === 1) {
+            parts.push('');
+        }
+        else if (char === PICK_SEPARATOR) {
+            endPick();
+            parts = [''];
+        }
+        else {
+            parts[parts.length - 1] += char;
+        }
+    }
+    endPick();
+    return picks;
+}
+// A select's values, kept or left out, read from its param, or undefined
+// when there are none or too many.
+function decodePicks(raw, as) {
+    const picks = decodePickList(raw)
+        .map((pick) => pick.value)
+        .filter((value) => value !== '');
+    return picks.length && picks.length <= GROUP_VALUE_MAX_PICKS ? { [as]: picks } : undefined;
+}
+// A range's set ends under their keys.
+function compactRange(low, high, lowKey, highKey) {
+    return {
+        ...(low !== null ? { [lowKey]: low } : {}),
+        ...(high !== null ? { [highKey]: high } : {}),
+    };
+}
+function isNumberEnd(end) {
+    return typeof end === 'number' && Number.isFinite(end);
+}
+function numberEndText(end) {
+    return isNumberEnd(end) ? String(end) : '';
+}
+// One 'level:value' step, or null when its level is not a time grain.
+function decodeDrillStep(item) {
+    const at = item.indexOf(DRILL_STEP_SEPARATOR);
+    const level = decodeItem(at < 0 ? item : item.slice(0, at));
+    if (!isChartGranularity(level)) {
+        return null;
+    }
+    return { level, value: at < 0 ? null : decodeItem(item.slice(at + 1)) };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-url-state.js","sourceRoot":"","sources":["../../../../src/app/reports/report-url-state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ParamMap, Params } from '@angular/router';\n\nimport {\n  FilterGroupValue, ReportFilterType, ReportSort, ReportUrlParams, ReportUrlSnapshot,\n} from './interfaces/report.interface';\nimport {\n  GROUP_BY_ITEM, GROUP_PARAM_PREFIX, dateBoundString, dateFromBound, groupItemName,\n} from './report-filter-items';\n\n\n// The report viewer's state in its URL: a pure codec, with no knowledge of a\n// loaded report. ReportFilterStateService decides WHAT is carried (only values\n// that differ from the authored defaults) and checks what is read back against\n// the report; this file only turns values into query params and back.\n//\n//   ?page=7&groupBy=week&g12=last30Days&g15=3,5&g16=2026-01-01..&s31=-create_date&q31=north&h31=notes,total\n//\n// - g<groupId>: one key per filter group. A dateRange is its relative preset\n//   name when it carries one, else 'YYYY-MM-DD..YYYY-MM-DD' (either side may be\n//   empty); a select is its values joined by ','; a keyword is its text. An\n//   empty value is an explicit clear of a group that has a default.\n// - s<componentId>: a list's sort column, '-' prefixed when descending.\n// - q<componentId>: the text in a list's search box.\n// - h<componentId>: the columns a viewer hid on a list (encodeColumnList).\n// - groupBy: the group-by grain (GROUP_BY_ITEM).\n// The page key is the host's (FsAiReportComponent.pageQueryParam) and is\n// written beside these, never by this codec.\n\n// The prefix of a group's value key. Declared beside the filter items, which\n// read it too (declaring it here would make the two files import each other);\n// re-exported so every codec constant can be imported from the codec.\nexport { GROUP_PARAM_PREFIX } from './report-filter-items';\n\n// The prefix of a list's sort key.\nexport const LIST_SORT_PARAM_PREFIX = 's';\n\n// Between the two days of an encoded fixed date range.\nexport const DATE_RANGE_SEPARATOR = '..';\n\n// The prefix of a list's search key.\nexport const LIST_SEARCH_PARAM_PREFIX = 'q';\n\n// The prefix of a list's hidden-columns key.\nexport const LIST_HIDDEN_PARAM_PREFIX = 'h';\n\n// The prefixes of the keys this codec owns, each followed by an id.\nconst OWNED_PREFIXES = [\n  GROUP_PARAM_PREFIX, LIST_SORT_PARAM_PREFIX, LIST_SEARCH_PARAM_PREFIX, LIST_HIDDEN_PARAM_PREFIX,\n];\n\n// A key this codec owns: a group value, or a list's sort, search or hidden\n// columns. Any such key the snapshot no longer carries is removed from the\n// URL, so a host must not keep its own state under a key of this shape (one\n// of the prefixes above, then digits).\nexport const OWNED_PARAM = new RegExp(`^[${OWNED_PREFIXES.join('')}]\\\\d+$`);\n\nconst DAY_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\n\n// The viewer-state params of a URL as raw strings. Keys this codec does not\n// own are ignored.\nexport function readReportUrlParams(params: ParamMap): ReportUrlParams {\n  const groups = new Map<number, string>();\n  const listSorts = new Map<number, string>();\n  const listSearches = new Map<number, string>();\n  const listHidden = new Map<number, string>();\n  // Each owned prefix names the map its keys go to; a prefix with no entry\n  // here is never read as some other kind of state.\n  const byPrefix: Record<string, Map<number, string>> = {\n    [GROUP_PARAM_PREFIX]: groups,\n    [LIST_SORT_PARAM_PREFIX]: listSorts,\n    [LIST_SEARCH_PARAM_PREFIX]: listSearches,\n    [LIST_HIDDEN_PARAM_PREFIX]: listHidden,\n  };\n\n  for (const key of params.keys) {\n    if (OWNED_PARAM.test(key)) {\n      byPrefix[key.charAt(0)]?.set(Number(key.slice(1)), params.get(key) ?? '');\n    }\n  }\n\n  return { groups, listSorts, listSearches, listHidden, groupBy: params.get(GROUP_BY_ITEM) };\n}\n\n// A list's hidden column names as one param value. A name is a query's output\n// alias, which can hold a comma, so each is percent-encoded before the join.\nexport function encodeColumnList(names: readonly string[]): string {\n  return names.map((name) => encodeURIComponent(name)).join(',');\n}\n\n// The column names of a hidden-columns param, in its order. Empty items are\n// dropped, and an item that does not decode (a hand-edited '%') is kept as\n// written. Whether a name is a column of the list is the caller's check.\nexport function decodeColumnList(raw: string): string[] {\n  return raw.split(',')\n    .filter((item) => item !== '')\n    .map((item) => {\n      try {\n        return decodeURIComponent(item);\n      } catch {\n        return item;\n      }\n    });\n}\n\n// A group value read back from its URL param. null is an explicit clear (an\n// empty param). undefined means the param is unusable for a group of this type\n// (an unknown preset name, a malformed day, a wrong shape) and is ignored.\n// `resolveRelative` turns a preset name into today's range for it, or null for\n// a name it does not know.\nexport function decodeFilterValue(\n  type: ReportFilterType,\n  raw: string,\n  resolveRelative: (name: string) => { start: Date; end: Date } | null,\n): FilterGroupValue | null | undefined {\n  if (raw === '') {\n    return null;\n  }\n\n  switch (type) {\n    case 'dateRange':\n      return raw.includes(DATE_RANGE_SEPARATOR)\n        ? decodeFixedRange(raw)\n        : decodePreset(raw, resolveRelative);\n\n    case 'select': {\n      const values = raw.split(',').filter((value) => value !== '');\n\n      return values.length ? { values } : undefined;\n    }\n\n    case 'keyword':\n      return raw.trim() ? { value: raw } : undefined;\n\n    default:\n      return undefined;\n  }\n}\n\n// A group value as its URL param. The shape says how: a preset name, then a\n// date range, then select values, then keyword text. null (a cleared group)\n// is the empty param.\nexport function encodeFilterValue(value: FilterGroupValue | null): string {\n  if (!value) {\n    return '';\n  }\n\n  if (value.preset) {\n    return value.preset;\n  }\n\n  if (value.start || value.end) {\n    return [dateBoundString(value.start) ?? '', dateBoundString(value.end) ?? '']\n      .join(DATE_RANGE_SEPARATOR);\n  }\n\n  if (value.values) {\n    return value.values.map((item) => String(item)).join(',');\n  }\n\n  return value.value ?? '';\n}\n\nexport function encodeSort(sort: ReportSort): string {\n  return `${sort.direction === 'desc' ? '-' : ''}${sort.column}`;\n}\n\n// A list sort read back from its URL param, or null when it names no column.\n// Whether the column is one the list can sort by is the caller's check.\nexport function decodeSort(raw: string): ReportSort | null {\n  const descending = raw.startsWith('-');\n  const column = descending ? raw.slice(1) : raw;\n\n  return column\n    ? { column, direction: descending ? 'desc' : 'asc' }\n    : null;\n}\n\n// The query params that make the URL carry `snapshot`: every snapshot key is\n// set, and each owned key (or the grain) that `current` carries but the\n// snapshot does not is set to null, which removes it under the router's\n// 'merge' handling. Keys this codec does not own are left alone.\nexport function buildReportUrlParams(snapshot: ReportUrlSnapshot, current: ParamMap): Params {\n  const params: Params = {};\n\n  for (const key of current.keys) {\n    if (OWNED_PARAM.test(key) || key === GROUP_BY_ITEM) {\n      params[key] = null;\n    }\n  }\n\n  snapshot.groups.forEach((value, groupId) => {\n    params[groupItemName({ id: groupId })] = encodeFilterValue(value);\n  });\n\n  snapshot.listSorts.forEach((sort, componentId) => {\n    params[`${LIST_SORT_PARAM_PREFIX}${componentId}`] = encodeSort(sort);\n  });\n\n  // The text as typed: the router percent-encodes it in the URL.\n  snapshot.listSearches.forEach((search, componentId) => {\n    params[`${LIST_SEARCH_PARAM_PREFIX}${componentId}`] = search;\n  });\n\n  snapshot.listHidden.forEach((names, componentId) => {\n    params[`${LIST_HIDDEN_PARAM_PREFIX}${componentId}`] = encodeColumnList(names);\n  });\n\n  if (snapshot.frequency) {\n    params[GROUP_BY_ITEM] = snapshot.frequency;\n  }\n\n  return params;\n}\n\n// 'YYYY-MM-DD..YYYY-MM-DD', either side optional but not both. Each side must\n// be a real calendar day.\nfunction decodeFixedRange(raw: string): FilterGroupValue | undefined {\n  const sides = raw.split(DATE_RANGE_SEPARATOR);\n  if (sides.length !== 2 || (!sides[0] && !sides[1])) {\n    return undefined;\n  }\n\n  const [start, end] = sides.map((side) => side ? decodeDay(side) : null);\n  if (start === undefined || end === undefined) {\n    return undefined;\n  }\n\n  return { start, end };\n}\n\n// One side of a fixed range as a local Date, or undefined when it is not a\n// real Y-M-D day.\nfunction decodeDay(side: string): Date | undefined {\n  return DAY_PATTERN.test(side) ? (dateFromBound(side) ?? undefined) : undefined;\n}\n\nfunction decodePreset(\n  name: string,\n  resolveRelative: (name: string) => { start: Date; end: Date } | null,\n): FilterGroupValue | undefined {\n  const range = resolveRelative(name);\n\n  return range ? { start: range.start, end: range.end, preset: name } : undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-url-state.js","sourceRoot":"","sources":["../../../../src/app/reports/report-url-state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ParamMap, Params } from '@angular/router';\n\nimport { iso8601 } from '@firestitch/date';\nimport { getExcludeName } from '@firestitch/filter';\n\nimport { parseISO } from 'date-fns';\n\nimport { ReportDrillStep } from './interfaces/report-drill-step.interface';\nimport { ReportFilterMatch } from './interfaces/report-filter-match.type';\nimport { ReportTileState } from './interfaces/report-tile-state.interface';\nimport { ReportUrlLink } from './interfaces/report-url-link.interface';\nimport { ReportUrlValueName } from './interfaces/report-url-value-name.type';\nimport { ReportUrlWrite } from './interfaces/report-url-write.interface';\nimport { ReportViewConfig } from './interfaces/report-view-config.interface';\nimport {\n  FilterGroupDefault, ReportFilterGroup, ReportFilterType, ReportSort, ReportUrlParams, ReportUrlSnapshot,\n} from './interfaces/report.interface';\nimport {\n  FORMAT_PARAM, GROUP_BY_ITEM, ItemRangeEnd, MATCH_ITEM, PERSONAL_VIEW_PARAM, VIEW_PARAM,\n  dateBoundString, groupParamKeys, itemRangeName,\n} from './report-filter-items';\nimport {\n  DRILL_MAX_DEPTH, GROUP_VALUE_MAX_PICKS, REPORT_VIEW_CONFIG_VERSION, isCalendarDay, isChartGranularity,\n  numberFromText, toStoredGroupValue,\n} from './report-view-config';\n\n\n// The report viewer's state in its URL: a pure codec. It knows the report's\n// filter groups only to name their keys; ReportFilterStateService decides\n// WHAT is carried (only values that differ from the link's base) and checks\n// what is read back against the report; this file only turns values into\n// query params and back. Each value below is as the codec writes it; the\n// router percent-encodes it again in the address bar.\n//\n//   ?page=7&groupBy=week&region=3:North,5:East&excludeStatus=2:Refunded\n//    &shippedFrom=2026-01-01T00:00:00-05:00&shippedTo=2026-01-31T00:00:00-05:00\n//    &unitsMin=0&unitsMax=50&s31=-create_date&q31=north\n//    &h31=notes,total&d44=year:2026-01-01,quarter:2026-07-01&match=any&rv=12&rf=2\n//\n// A filter group is written under its fs-filter item's own query keys, so\n// the bar and the link have one syntax. <key> is the group's key, the\n// camelCase of its label ('Region' -> region; groupParamKeys in\n// report-filter-items.ts, which also says what a clash falls back to:\n// region12).\n// - A select: <key>=value:name,... for the values it keeps and\n//   exclude<Key>=value:name,... for the values it leaves out. This is\n//   fs-filter's own syntax: ',' between picks, ':' between a value and its\n//   name, and a ',', ':' or '\\' inside either one escaped with '\\'. The name\n//   is the one the chip showed when the link was written, and is left off\n//   while the viewer has not seen it. Only the value is read back: names come\n//   from the option list, so a renamed option shows its new name.\n// - A number range: <key>Min and <key>Max, either one open.\n// - A date range: <key>From and <key>To in fs-filter's date format (the\n//   day's local midnight with its offset, 2026-01-01T00:00:00-05:00), either\n//   one open. Only the day is read back, so a link opens on the same days in\n//   every zone. A link never names a preset: a date picker preset only sets\n//   the days, and a rolling range (a report's relative default) is not written\n//   while it is the link's base, and is written as its days when it must be\n//   (the caller turns it into days first; see groupValueParams).\n// - A keyword: <key>=text.\n// An empty value is an explicit clear of a group that has a default: <key>=\n// for a select or a keyword, both ends empty for a range.\n// The other keys:\n// - s<componentId>: a list's sort column, '-' prefixed when descending.\n// - q<componentId>: the text in a list's search box.\n// - h<componentId>: the columns a viewer hid on a list (encodeColumnList).\n// - d<componentId>: a chart's drill path, 'level:value' steps (each part\n//   percent-encoded) joined by ','.\n// - groupBy: the group-by grain (GROUP_BY_ITEM).\n// - match=any: the groups combine with any (absent = all).\n// - rv: the shared view the state is a diff from. rpv: the open personal\n//   view, a label only, never a base.\n// - rf=2: the format every link this viewer writes carries.\n// A key this codec does not know is ignored and left in the URL as it is.\n// The page key is the host's (FsAiReportComponent.pageQueryParam) and is\n// written beside these, never by this codec. The cross-filter and the rows\n// panel are never in the URL.\n//\n// The keys the codec owns: the tile keys, groupBy, match, rv, rpv, rf, and\n// every key a group of the open report is written under. A write removes an\n// owned key it no longer carries, so a host must not keep its own state\n// under one. A group key comes from a label, so a host param named like one\n// (a group labeled 'Status' owns status and excludeStatus) is the codec's.\n// Only the default page key, 'page', is kept off the groups.\n\n// The keys of the views and the format. Declared beside the filter items,\n// which keep a group key off them (declaring them here would make the two\n// files import each other); re-exported so every codec constant can be\n// imported from the codec.\nexport { FORMAT_PARAM, PERSONAL_VIEW_PARAM, VIEW_PARAM } from './report-filter-items';\n\n// The prefix of a list's sort key.\nexport const LIST_SORT_PARAM_PREFIX = 's';\n\n// The prefix of a list's search key.\nexport const LIST_SEARCH_PARAM_PREFIX = 'q';\n\n// The prefix of a list's hidden-columns key.\nexport const LIST_HIDDEN_PARAM_PREFIX = 'h';\n\n// The prefix of a chart's drill-path key.\nexport const DRILL_PARAM_PREFIX = 'd';\n\n// The match's key: the report bar's Match item's own name.\nexport const MATCH_PARAM = MATCH_ITEM;\n\n// The format a link this viewer writes carries.\nexport const URL_FORMAT = 2;\n\n// Between a drill step's level and its value.\nexport const DRILL_STEP_SEPARATOR = ':';\n\n// Between a select's picks, and between a pick's value and its name\n// (fs-filter's AutoCompleteChips syntax).\nexport const PICK_SEPARATOR = ',';\nexport const PICK_NAME_SEPARATOR = ':';\n\n// Before a ',', ':' or '\\' that is part of a pick's value or name.\nconst PICK_ESCAPE = '\\\\';\n\n// The most characters the codec's params may take in a link (the host's own\n// path and params are not counted).\nexport const REPORT_URL_MAX_LENGTH = 2000;\n\n// Shown once when a link left group values out (ReportUrlWrite.tooLong).\nexport const URL_TOO_LONG_MESSAGE = 'This filter is too long for a link; save a view to share it.';\n\nconst MATCH_ANY: ReportFilterMatch = 'any';\n\n// The prefixes of the tile keys this codec owns, each followed by an id.\nconst OWNED_PREFIXES = [LIST_SORT_PARAM_PREFIX, LIST_SEARCH_PARAM_PREFIX, LIST_HIDDEN_PARAM_PREFIX, DRILL_PARAM_PREFIX];\n\n// The keys this codec owns that carry no id and do not depend on the report.\nconst OWNED_KEYS = [GROUP_BY_ITEM, MATCH_PARAM, VIEW_PARAM, PERSONAL_VIEW_PARAM, FORMAT_PARAM];\n\n// A key of one of the prefixes above, followed by its id.\nconst ID_PARAM = new RegExp(`^([${OWNED_PREFIXES.join('')}])(\\\\d+)$`);\n\n// A key this codec owns whatever the report: a list's sort, search or hidden\n// columns; a chart's drill path; the grain, the match, the two views and the\n// format. The groups' keys are owned too (see the top of this file).\nexport const OWNED_PARAM = new RegExp(`^(?:[${OWNED_PREFIXES.join('')}]\\\\d+|${OWNED_KEYS.join('|')})$`);\n\n// A link's day: 'yyyy-MM-dd', alone or as the start of fs-filter's date\n// format ('T' and a time and offset after it).\nconst LINK_DAY = /^(\\d{4}-\\d{2}-\\d{2})(?:T.*)?$/;\n\ntype UrlGroup = Pick<ReportFilterGroup, 'id' | 'type' | 'label' | 'filters'>;\n\n// The viewer-state params of a URL: the groups' values in their stored shape\n// (null for a group the link clears; read as paramsToViewConfig reads them),\n// the rest as raw strings. Keys this codec does not own are ignored.\n// `groups` is every filter group of the report.\nexport function readReportUrlParams(params: ParamMap, groups: readonly UrlGroup[]): ReportUrlParams {\n  const listSorts = new Map<number, string>();\n  const listSearches = new Map<number, string>();\n  const listHidden = new Map<number, string>();\n  // Each prefix read here names the map its keys go to; a prefix with no\n  // entry is never read as some other kind of state.\n  const byPrefix: Record<string, Map<number, string>> = {\n    [LIST_SORT_PARAM_PREFIX]: listSorts,\n    [LIST_SEARCH_PARAM_PREFIX]: listSearches,\n    [LIST_HIDDEN_PARAM_PREFIX]: listHidden,\n  };\n  const query: Params = {};\n\n  for (const key of params.keys) {\n    query[key] = params.get(key) ?? '';\n    const owned = ID_PARAM.exec(key);\n    if (owned) {\n      byPrefix[owned[1]]?.set(Number(owned[2]), params.get(key) ?? '');\n    }\n  }\n\n  return {\n    groups: readGroupParams(query, groups),\n    listSorts, listSearches, listHidden,\n    groupBy: params.get(GROUP_BY_ITEM),\n  };\n}\n\n// The viewer state a link carries, as a view config: its group values (read\n// by each group's type, so a group the report does not have is skipped), the\n// grain, the match and each tile's sort, search, hidden columns and drill\n// path. A param that is unusable is left out. Whether a tile's component and\n// a list's columns exist is the caller's check. `groups` is every filter\n// group of the report.\nexport function paramsToViewConfig(params: Params, groups: readonly UrlGroup[]): ReportViewConfig {\n  const config: ReportViewConfig = { v: REPORT_VIEW_CONFIG_VERSION };\n\n  const groupBy = paramText(params[GROUP_BY_ITEM]);\n  if (isChartGranularity(groupBy)) {\n    config.groupBy = groupBy;\n  }\n\n  if (paramText(params[MATCH_PARAM]) === MATCH_ANY) {\n    config.match = MATCH_ANY;\n  }\n\n  readGroupParams(params, groups).forEach((value, groupId) => {\n    config.groups = { ...config.groups, [groupId]: value };\n  });\n\n  Object.keys(params).forEach((key) => {\n    const owned = ID_PARAM.exec(key);\n    const raw = paramText(params[key]);\n\n    if (owned && raw !== null) {\n      readTileParam(config, owned[1], Number(owned[2]), raw);\n    }\n  });\n\n  return config;\n}\n\n// The params that make a link carry `config`, the views it names, and rf=2.\n// Each group is written under its keys among `groups` (every filter group of\n// the report); a group the report no longer has is left out. `name` names a\n// select's values. Past REPORT_URL_MAX_LENGTH the longest group values are\n// left out (those groups then open at the link's base) and tooLong is set.\nexport function viewConfigToParams(\n  config: ReportViewConfig,\n  groups: readonly UrlGroup[],\n  link: ReportUrlLink = {},\n  name: ReportUrlValueName = () => null,\n): ReportUrlWrite {\n  const params: Record<string, string> = {};\n  const keys = groupParamKeys(groups);\n  const types = new Map(groups.map((group) => [group.id, group.type]));\n  const groupParams = new Set<string>();\n\n  if (config.groupBy) {\n    params[GROUP_BY_ITEM] = config.groupBy;\n  }\n\n  Object.entries(config.groups ?? {}).forEach(([id, value]) => {\n    const groupId = Number(id);\n    const key = keys.get(groupId);\n    if (key) {\n      const written = groupValueParams(types.get(groupId), key, value, (pick) => name(groupId, pick));\n      Object.assign(params, written);\n      Object.keys(written).forEach((param) => groupParams.add(param));\n    }\n  });\n\n  Object.entries(config.tiles ?? {}).forEach(([componentId, tile]) => {\n    Object.assign(params, tileParams(Number(componentId), tile));\n  });\n\n  if (config.match === MATCH_ANY) {\n    params[MATCH_PARAM] = MATCH_ANY;\n  }\n\n  if (link.viewId) {\n    params[VIEW_PARAM] = String(link.viewId);\n  }\n\n  if (link.personalViewId) {\n    params[PERSONAL_VIEW_PARAM] = String(link.personalViewId);\n  }\n\n  return capReportParams(withFormat(params), groupParams);\n}\n\n// The views a link names, each a positive id or null.\nexport function readReportUrlLink(params: Params): ReportUrlLink {\n  return {\n    viewId: positiveId(paramText(params[VIEW_PARAM])),\n    personalViewId: positiveId(paramText(params[PERSONAL_VIEW_PARAM])),\n  };\n}\n\n// Whether a link carries viewer state of its own, so it opens on that state\n// rather than on a default view: any owned key but the format marker and the\n// personal view, which is a label only. `groups` is every filter group of\n// the report.\nexport function hasReportUrlState(params: Params, groups: readonly UrlGroup[]): boolean {\n  const groupKeys = ownedGroupKeys(groups);\n\n  return Object.keys(params).some((key) => ID_PARAM.test(key) || groupKeys.has(key)\n    || key === GROUP_BY_ITEM || key === MATCH_PARAM || key === VIEW_PARAM);\n}\n\n// Every owned key `current` carries, set to null: under the router's 'merge'\n// handling, a write spread over these removes the keys it no longer carries.\n// Keys this codec does not own are left alone. `groups` is every filter\n// group of the report.\nexport function reportParamsToClear(current: ParamMap, groups: readonly UrlGroup[]): Params {\n  const groupKeys = ownedGroupKeys(groups);\n  const params: Params = {};\n\n  for (const key of current.keys) {\n    if (OWNED_PARAM.test(key) || groupKeys.has(key)) {\n      params[key] = null;\n    }\n  }\n\n  return params;\n}\n\n// The names the select picks in `current` (the URL as it is) carry, so a\n// write can keep a name the viewer's lists have not named yet. Only a write\n// reads these: what the chips show comes from the lists.\nexport function urlValueNames(current: ParamMap, groups: readonly UrlGroup[]): ReportUrlValueName {\n  const keys = groupParamKeys(groups);\n  const names = new Map<number, Map<string, string>>();\n\n  groups\n    .filter((group) => group.type === 'select')\n    .forEach((group) => {\n      const key = keys.get(group.id);\n      const picks = [current.get(key), current.get(getExcludeName(key))]\n        .flatMap((raw) => (raw ? decodePickList(raw) : []))\n        .filter((pick) => pick.name !== null);\n\n      names.set(group.id, new Map(picks.map((pick) => [pick.value, pick.name])));\n    });\n\n  return (groupId, value) => names.get(groupId)?.get(String(value)) ?? null;\n}\n\n// A list's hidden column names as one param value. A name is a query's output\n// alias, which can hold a comma, so each is percent-encoded before the join.\nexport function encodeColumnList(names: readonly string[]): string {\n  return names.map((name) => encodeURIComponent(name)).join(',');\n}\n\n// The column names of a hidden-columns param, in its order. Empty items are\n// dropped, and an item that does not decode (a hand-edited '%') is kept as\n// written. Whether a name is a column of the list is the caller's check.\nexport function decodeColumnList(raw: string): string[] {\n  return raw.split(',')\n    .filter((item) => item !== '')\n    .map(decodeItem);\n}\n\n// A group's value in its stored shape as the link's params under the group's\n// key (see the top of this file): days, then a select's values left out, then\n// its values kept, then a number range, then keyword text. null (a cleared\n// group), or a value that holds nothing, is the group's keys, empty. A\n// relative range with no days is not written at all: a link carries days, and\n// only the caller has the report's zone and clock to give them\n// (ReportViewService). `name` names a select's value.\nexport function groupValueParams(\n  type: ReportFilterType | undefined,\n  key: string,\n  value: FilterGroupDefault | null,\n  name: (value: unknown) => string | null = () => null,\n): Record<string, string> {\n  if (!value) {\n    return clearParams(type, key);\n  }\n\n  if (value.start || value.end) {\n    return rangeParams(type, key, ['from', 'to'], [linkDayText(value.start), linkDayText(value.end)]);\n  }\n\n  if (value.excludeValues?.length) {\n    return { [getExcludeName(key)]: encodePicks(value.excludeValues, name) };\n  }\n\n  if (value.values) {\n    return { [key]: encodePicks(value.values, name) };\n  }\n\n  if (isNumberEnd(value.min) || isNumberEnd(value.max)) {\n    return rangeParams(type, key, ['min', 'max'], [numberEndText(value.min), numberEndText(value.max)]);\n  }\n\n  if (value.relative) {\n    return {};\n  }\n\n  return value.value ? { [key]: value.value } : clearParams(type, key);\n}\n\nexport function encodeSort(sort: ReportSort): string {\n  return `${sort.direction === 'desc' ? '-' : ''}${sort.column}`;\n}\n\n// A list sort read back from its URL param, or null when it names no column.\n// Whether the column is one the list can sort by is the caller's check.\nexport function decodeSort(raw: string): ReportSort | null {\n  const descending = raw.startsWith('-');\n  const column = descending ? raw.slice(1) : raw;\n\n  return column\n    ? { column, direction: descending ? 'desc' : 'asc' }\n    : null;\n}\n\n// A drill path as its URL param. A step with no value writes its level only.\nexport function encodeDrillPath(path: readonly ReportDrillStep[]): string {\n  return path\n    .map((step) => (step.value === null || step.value === undefined\n      ? encodeURIComponent(step.level)\n      : `${encodeURIComponent(step.level)}${DRILL_STEP_SEPARATOR}${encodeURIComponent(String(step.value))}`))\n    .join(',');\n}\n\n// A drill path read back from its URL param: its steps up to the first that\n// is not a time level (the steps before it are kept), at most DRILL_MAX_DEPTH\n// of them. Values come back as text. Whether the path fits the chart is the\n// server's check (it applies the longest valid prefix).\nexport function decodeDrillPath(raw: string): ReportDrillStep[] {\n  const path: ReportDrillStep[] = [];\n\n  for (const item of raw.split(',')) {\n    const step = decodeDrillStep(item);\n    if (!step || path.length === DRILL_MAX_DEPTH) {\n      break;\n    }\n\n    path.push(step);\n  }\n\n  return path;\n}\n\n// The query params that make the URL carry `snapshot`: every snapshot key is\n// set, and each owned key that `current` carries but the snapshot does not is\n// set to null, which removes it under the router's 'merge' handling. Keys\n// this codec does not own are left alone. Each group is written under its\n// keys among `groups` (every filter group of the report). A select's value\n// is named by `name`, else by the name `current` carries for it. A date range\n// is written as the days on screen, never as a preset name.\nexport function buildReportUrlParams(\n  snapshot: ReportUrlSnapshot,\n  current: ParamMap,\n  groups: readonly UrlGroup[],\n  name: ReportUrlValueName = () => null,\n): Params {\n  const params: Record<string, string> = {};\n  const keys = groupParamKeys(groups);\n  const types = new Map(groups.map((group) => [group.id, group.type]));\n  const currentName = urlValueNames(current, groups);\n\n  snapshot.groups.forEach((value, groupId) => {\n    const key = keys.get(groupId);\n    if (key) {\n      const type = types.get(groupId);\n      const named = (pick: unknown) => name(groupId, pick) ?? currentName(groupId, pick);\n      const days = value ? { ...value, preset: undefined } : value;\n      Object.assign(params, groupValueParams(type, key, toStoredGroupValue(type, days), named));\n    }\n  });\n\n  snapshot.listSorts.forEach((sort, componentId) => {\n    params[`${LIST_SORT_PARAM_PREFIX}${componentId}`] = encodeSort(sort);\n  });\n\n  // The text as typed: the router percent-encodes it in the URL.\n  snapshot.listSearches.forEach((search, componentId) => {\n    params[`${LIST_SEARCH_PARAM_PREFIX}${componentId}`] = search;\n  });\n\n  snapshot.listHidden.forEach((names, componentId) => {\n    params[`${LIST_HIDDEN_PARAM_PREFIX}${componentId}`] = encodeColumnList(names);\n  });\n\n  if (snapshot.frequency) {\n    params[GROUP_BY_ITEM] = snapshot.frequency;\n  }\n\n  return { ...reportParamsToClear(current, groups), ...withFormat(params) };\n}\n\n// `params` with the format marker, when it carries anything.\nfunction withFormat(params: Record<string, string>): Record<string, string> {\n  return Object.keys(params).length ? { ...params, [FORMAT_PARAM]: String(URL_FORMAT) } : params;\n}\n\n// Each group's value a link carries, in its stored shape, by group id (null\n// for a group the link clears). A group with no usable param is left out.\nfunction readGroupParams(params: Params, groups: readonly UrlGroup[]): Map<number, FilterGroupDefault | null> {\n  const keys = groupParamKeys(groups);\n  const values = new Map<number, FilterGroupDefault | null>();\n\n  for (const group of groups) {\n    const value = readGroupParam(params, group.type, keys.get(group.id));\n    if (value !== undefined) {\n      values.set(group.id, value);\n    }\n  }\n\n  return values;\n}\n\n// One group's value in a link, read from the keys of its type. null is a\n// clear; undefined is no usable value.\nfunction readGroupParam(params: Params, type: ReportFilterType, key: string): FilterGroupDefault | null | undefined {\n  switch (type) {\n    case 'select':\n      return readSelect(params, key);\n\n    case 'dateRange':\n      return readDateRange(params, key);\n\n    case 'numberRange':\n      return readNumberRange(params, key);\n\n    case 'keyword':\n      return readKeyword(params[key]);\n\n    default:\n      return undefined;\n  }\n}\n\n// A select's values kept (<key>), else its values left out (exclude<Key>).\nfunction readSelect(params: Params, key: string): FilterGroupDefault | null | undefined {\n  const kept = paramText(params[key]);\n  if (kept !== null) {\n    return kept === '' ? null : decodePicks(kept, 'values');\n  }\n\n  const excluded = paramText(params[getExcludeName(key)]);\n  if (excluded !== null) {\n    return excluded === '' ? null : decodePicks(excluded, 'excludeValues');\n  }\n\n  return undefined;\n}\n\n// A date range's days (<key>From, <key>To), each a real calendar day,\n// either one open but not both.\nfunction readDateRange(params: Params, key: string): FilterGroupDefault | null | undefined {\n  const ends = readRangeEnds(params, key, ['from', 'to']);\n  if (!ends) {\n    return ends === null ? null : undefined;\n  }\n\n  const [start, end] = ends.map(linkDay);\n  if (start === undefined || end === undefined) {\n    return undefined;\n  }\n\n  return compactRange(start, end, 'start', 'end');\n}\n\n// A number range's ends (<key>Min, <key>Max), each a finite number, either\n// one open but not both, and min not above max.\nfunction readNumberRange(params: Params, key: string): FilterGroupDefault | null | undefined {\n  const ends = readRangeEnds(params, key, ['min', 'max']);\n  if (!ends) {\n    return ends === null ? null : undefined;\n  }\n\n  const [min, max] = ends.map((end) => (end === '' ? null : numberFromText(end)));\n  if ((ends[0] !== '' && min === null) || (ends[1] !== '' && max === null) || (min !== null && max !== null && min > max)) {\n    return undefined;\n  }\n\n  return compactRange(min, max, 'min', 'max');\n}\n\n// A keyword's text. Blank text is unusable.\nfunction readKeyword(raw: unknown): FilterGroupDefault | null | undefined {\n  const text = paramText(raw);\n  if (text === null) {\n    return undefined;\n  }\n\n  if (text === '') {\n    return null;\n  }\n\n  return text.trim() ? { value: text } : undefined;\n}\n\n// A range's two ends as written ('' for one the link leaves open):\n// undefined when the link carries neither key, null when every one it\n// carries is empty (a clear).\nfunction readRangeEnds(\n  params: Params,\n  key: string,\n  ends: [ItemRangeEnd, ItemRangeEnd],\n): [string, string] | null | undefined {\n  const [low, high] = ends.map((end) => paramText(params[itemRangeName(key, end)]));\n  if (low === null && high === null) {\n    return undefined;\n  }\n\n  return low || high ? [low ?? '', high ?? ''] : null;\n}\n\n// The params of a range's ends, the ones it sets only; with neither one\n// usable, the group's clear.\nfunction rangeParams(\n  type: ReportFilterType | undefined,\n  key: string,\n  ends: [ItemRangeEnd, ItemRangeEnd],\n  texts: [string, string],\n): Record<string, string> {\n  const params: Record<string, string> = {};\n  ends.forEach((end, index) => {\n    if (texts[index]) {\n      params[itemRangeName(key, end)] = texts[index];\n    }\n  });\n\n  return Object.keys(params).length ? params : clearParams(type, key);\n}\n\n// The params of a cleared group: its keys, empty.\nfunction clearParams(type: ReportFilterType | undefined, key: string): Record<string, string> {\n  switch (type) {\n    case 'dateRange':\n      return { [itemRangeName(key, 'from')]: '', [itemRangeName(key, 'to')]: '' };\n\n    case 'numberRange':\n      return { [itemRangeName(key, 'min')]: '', [itemRangeName(key, 'max')]: '' };\n\n    default:\n      return { [key]: '' };\n  }\n}\n\n// A stored day in fs-filter's date format: its local midnight with the\n// offset, '' when there is no real day.\nfunction linkDayText(bound: string | undefined): string {\n  const day = dateBoundString(bound);\n\n  return day && isCalendarDay(day) ? iso8601(parseISO(day)) : '';\n}\n\n// The day of a link's date end: null when the end is open (''), undefined\n// when it is not a real calendar day.\nfunction linkDay(text: string): string | null | undefined {\n  if (text === '') {\n    return null;\n  }\n\n  const day = LINK_DAY.exec(text)?.[1];\n\n  return day && isCalendarDay(day) ? day : undefined;\n}\n\n// The keys a link carries the groups' values under, by each group's type.\nfunction ownedGroupKeys(groups: readonly UrlGroup[]): Set<string> {\n  const keys = groupParamKeys(groups);\n\n  return new Set(groups.flatMap((group) => {\n    const key = keys.get(group.id);\n\n    switch (group.type) {\n      case 'select':\n        return [key, getExcludeName(key)];\n\n      case 'dateRange':\n        return [itemRangeName(key, 'from'), itemRangeName(key, 'to')];\n\n      case 'numberRange':\n        return [itemRangeName(key, 'min'), itemRangeName(key, 'max')];\n\n      default:\n        return [key];\n    }\n  }));\n}\n\n// One id-keyed param of a tile read into `config`.\nfunction readTileParam(\n  config: ReportViewConfig,\n  prefix: string,\n  id: number,\n  raw: string,\n): void {\n  switch (prefix) {\n    case LIST_SORT_PARAM_PREFIX:\n      setTileState(config, id, 'sort', decodeSort(raw));\n      break;\n\n    case LIST_SEARCH_PARAM_PREFIX:\n      setTileState(config, id, 'search', raw || null);\n      break;\n\n    case LIST_HIDDEN_PARAM_PREFIX:\n      setTileState(config, id, 'hidden', nonEmpty(decodeColumnList(raw)));\n      break;\n\n    default:\n      setTileState(config, id, 'drill', nonEmpty(decodeDrillPath(raw)));\n  }\n}\n\n// Sets one key of a tile's state, creating the tile, unless there is nothing\n// to set.\nfunction setTileState<K extends keyof ReportTileState>(\n  config: ReportViewConfig,\n  componentId: number,\n  key: K,\n  value: ReportTileState[K] | null,\n): void {\n  if (value === null) {\n    return;\n  }\n\n  config.tiles = { ...config.tiles, [componentId]: { ...config.tiles?.[componentId], [key]: value } };\n}\n\n// The params of one tile's state.\nfunction tileParams(componentId: number, tile: ReportTileState): Record<string, string> {\n  const params: Record<string, string> = {};\n\n  if (tile.sort?.column) {\n    params[`${LIST_SORT_PARAM_PREFIX}${componentId}`] = encodeSort(tile.sort);\n  }\n\n  // The text as typed: the router percent-encodes it in the URL.\n  if (tile.search) {\n    params[`${LIST_SEARCH_PARAM_PREFIX}${componentId}`] = tile.search;\n  }\n\n  if (tile.hidden?.length) {\n    params[`${LIST_HIDDEN_PARAM_PREFIX}${componentId}`] = encodeColumnList(tile.hidden);\n  }\n\n  if (tile.drill?.length) {\n    params[`${DRILL_PARAM_PREFIX}${componentId}`] = encodeDrillPath(tile.drill);\n  }\n\n  return params;\n}\n\n// `params` within REPORT_URL_MAX_LENGTH: past it, group values (the params\n// named in `groupParams`) are left out, longest first, until the rest fits.\nfunction capReportParams(params: Record<string, string>, groupParams: ReadonlySet<string>): ReportUrlWrite {\n  if (queryLength(params) <= REPORT_URL_MAX_LENGTH) {\n    return { params, tooLong: false };\n  }\n\n  const kept = { ...params };\n  const groupKeys = Object.keys(kept)\n    .filter((key) => groupParams.has(key))\n    .sort((a, b) => queryText(kept[b]).length - queryText(kept[a]).length);\n\n  for (const key of groupKeys) {\n    if (queryLength(kept) <= REPORT_URL_MAX_LENGTH) {\n      break;\n    }\n\n    delete kept[key];\n  }\n\n  return { params: kept, tooLong: true };\n}\n\n// The length of `params` as the router writes them in a query string.\nfunction queryLength(params: Record<string, string>): number {\n  return Object.entries(params)\n    .map(([key, value]) => `${queryText(key)}=${queryText(value)}`)\n    .join('&')\n    .length;\n}\n\n// Text as the router writes it in a query string (its query encoding):\n// percent-encoded, with '@', ':', '$', ',' and ';' left as they are.\nfunction queryText(text: string): string {\n  return encodeURIComponent(text)\n    .replace(/%40/g, '@')\n    .replace(/%3A/gi, ':')\n    .replace(/%24/g, '$')\n    .replace(/%2C/gi, ',')\n    .replace(/%3B/gi, ';');\n}\n\n// A param's text: a repeated key gives its first value.\nfunction paramText(value: unknown): string | null {\n  const first = Array.isArray(value) ? value[0] : value;\n\n  return typeof first === 'string' || typeof first === 'number' ? String(first) : null;\n}\n\nfunction positiveId(raw: string | null): number | null {\n  return raw !== null && /^[1-9]\\d*$/.test(raw) ? Number(raw) : null;\n}\n\nfunction nonEmpty<T>(list: T[]): T[] | null {\n  return list.length ? list : null;\n}\n\n// An item of a list param, percent-decoded; one that does not decode (a\n// hand-edited '%') is kept as written.\nfunction decodeItem(item: string): string {\n  try {\n    return decodeURIComponent(item);\n  } catch {\n    return item;\n  }\n}\n\n// Select picks as one param value: value:name for each, the name left off\n// when `name` does not know it, blanks left out.\nfunction encodePicks(picks: readonly unknown[], name: (value: unknown) => string | null): string {\n  return picks\n    .filter((pick) => typeof pick === 'string' || typeof pick === 'number' || typeof pick === 'boolean')\n    .filter((pick) => String(pick) !== '')\n    .map((pick) => {\n      const named = name(pick);\n\n      return named ? `${escapePick(String(pick))}${PICK_NAME_SEPARATOR}${escapePick(named)}` : escapePick(String(pick));\n    })\n    .join(PICK_SEPARATOR);\n}\n\n// A pick's value or name with each ',', ':' and '\\' in it escaped.\nfunction escapePick(text: string): string {\n  return text.replace(/[\\\\,:]/g, (char) => `${PICK_ESCAPE}${char}`);\n}\n\n// The picks of a param written as encodePicks writes them, in order: each\n// value and its name (null when the pick has none).\nfunction decodePickList(raw: string): { value: string; name: string | null }[] {\n  const picks: { value: string; name: string | null }[] = [];\n  let parts: string[] = [''];\n  let escaped = false;\n  const endPick = () => picks.push({ value: parts[0], name: parts.length > 1 ? parts[1] : null });\n\n  for (const char of raw) {\n    if (escaped) {\n      parts[parts.length - 1] += char;\n      escaped = false;\n    } else if (char === PICK_ESCAPE) {\n      escaped = true;\n    } else if (char === PICK_NAME_SEPARATOR && parts.length === 1) {\n      parts.push('');\n    } else if (char === PICK_SEPARATOR) {\n      endPick();\n      parts = [''];\n    } else {\n      parts[parts.length - 1] += char;\n    }\n  }\n\n  endPick();\n\n  return picks;\n}\n\n// A select's values, kept or left out, read from its param, or undefined\n// when there are none or too many.\nfunction decodePicks(raw: string, as: 'values' | 'excludeValues'): FilterGroupDefault | undefined {\n  const picks = decodePickList(raw)\n    .map((pick) => pick.value)\n    .filter((value) => value !== '');\n\n  return picks.length && picks.length <= GROUP_VALUE_MAX_PICKS ? { [as]: picks } : undefined;\n}\n\n// A range's set ends under their keys.\nfunction compactRange<T>(low: T | null, high: T | null, lowKey: string, highKey: string): FilterGroupDefault {\n  return {\n    ...(low !== null ? { [lowKey]: low } : {}),\n    ...(high !== null ? { [highKey]: high } : {}),\n  };\n}\n\nfunction isNumberEnd(end: unknown): end is number {\n  return typeof end === 'number' && Number.isFinite(end);\n}\n\nfunction numberEndText(end: unknown): string {\n  return isNumberEnd(end) ? String(end) : '';\n}\n\n// One 'level:value' step, or null when its level is not a time grain.\nfunction decodeDrillStep(item: string): ReportDrillStep | null {\n  const at = item.indexOf(DRILL_STEP_SEPARATOR);\n  const level = decodeItem(at < 0 ? item : item.slice(0, at));\n\n  if (!isChartGranularity(level)) {\n    return null;\n  }\n\n  return { level, value: at < 0 ? null : decodeItem(item.slice(at + 1)) };\n}\n"]}