@firestitch/report 18.10.1 → 18.11.0

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

@@ -0,0 +1,169 @@
+import { GRANULARITY_OPTIONS, } from './interfaces/report.interface';
+import { dateBoundString } from './report-filter-items';
+// The server's cap on a drill path.
+export const DRILL_MAX_DEPTH = 5;
+// Every relative range name the server knows, in its enum's order. A record
+// rather than a list, so the build fails when ReportRelativeRange gains a
+// name this misses.
+const RELATIVE_RANGES = {
+    thisWeek: true,
+    lastWeek: true,
+    last7Days: true,
+    last30Days: true,
+    last3Months: true,
+    last6Months: true,
+    last12Months: true,
+    thisMonth: true,
+    thisQuarter: true,
+    thisYear: true,
+    yearToDate: true,
+};
+// The same names as a list, in the server enum's order (the record's key
+// order): the order the date picker offers them in.
+export const RELATIVE_RANGE_NAMES = Object.keys(RELATIVE_RANGES);
+const DAY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+// A number as text: what a masked input sends.
+const NUMBER_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+// Whether a name is a relative range the server resolves.
+export function isRelativeRange(name) {
+    return typeof name === 'string' && Object.prototype.hasOwnProperty.call(RELATIVE_RANGES, name);
+}
+export function isChartGranularity(value) {
+    return GRANULARITY_OPTIONS.some((option) => option.value === value);
+}
+// Whether text is a real calendar day written 'yyyy-MM-dd' (no 2026-02-30).
+export function isCalendarDay(text) {
+    const parts = DAY_PATTERN.exec(text);
+    if (!parts) {
+        return false;
+    }
+    const [year, month, day] = parts.slice(1).map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+// A number written as text (a masked input's value), or null when the text
+// is not one finite number.
+export function numberFromText(text) {
+    const number = NUMBER_PATTERN.test(text) ? Number(text) : NaN;
+    return Number.isFinite(number) ? number : null;
+}
+// A group's value in its stored shape, read for the keys its group's type
+// owns, or null when it holds nothing. A date range that still carries its
+// relative preset is written as that preset whatever today is.
+export function toStoredGroupValue(type, value) {
+    if (!value) {
+        return null;
+    }
+    switch (type) {
+        case 'dateRange':
+            return isRelativeRange(value.preset)
+                ? { relative: value.preset }
+                : storedOrNull({ start: dateBoundString(value.start), end: dateBoundString(value.end) });
+        case 'select': {
+            const excludeValues = keptPicks(value.excludeValues);
+            return storedOrNull(excludeValues ? { excludeValues } : { values: keptPicks(value.values) });
+        }
+        case 'numberRange':
+            return storedOrNull({ min: finiteNumber(value.min), max: finiteNumber(value.max) });
+        default:
+            return storedOrNull({ value: value.value?.trim() || undefined });
+    }
+}
+// Whether the screen's state (`current`, a snapshot) differs from the
+// report's authored defaults (`defaults`): the match, the grain, a group's
+// value, or a tile's sort, search, hidden columns or drill path. The page is
+// not compared (moving to another page changes no filter). Picks are
+// compared in any order.
+export function stateDiffers(defaults, current) {
+    return (defaults.match ?? 'all') !== (current.match ?? 'all')
+        || (defaults.groupBy ?? null) !== (current.groupBy ?? null)
+        || Object.entries(current.groups ?? {})
+            .some(([groupId, value]) => storedValueKey(defaults.groups?.[Number(groupId)]) !== storedValueKey(value))
+        || tilesDiffer(defaults.tiles ?? {}, current.tiles ?? {});
+}
+// Whether two stored group values are the same filter: picks in any order,
+// text trimmed, an empty value read as none.
+export function sameStoredGroupValue(a, b) {
+    return storedValueKey(a) === storedValueKey(b);
+}
+// A drill path kept to what a tile can carry: its steps up to the first that
+// is not a time level with a plain value (the steps before it are kept), at
+// most DRILL_MAX_DEPTH of them.
+export function cleanDrillPath(path) {
+    const kept = [];
+    for (const step of path ?? []) {
+        if (!isPlainObject(step) || !isChartGranularity(step.level) || !isDrillValue(step.value)
+            || kept.length === DRILL_MAX_DEPTH) {
+            break;
+        }
+        kept.push({ level: step.level, value: step.value });
+    }
+    return kept;
+}
+// Whether two drill paths are the same steps. A value is compared as text,
+// so 2026 and '2026' are the same step.
+export function sameDrillPath(a, b) {
+    return drillKey(a) === drillKey(b);
+}
+// A range end as a number. A masked input sends its number as text, so
+// numeric text is read as its number.
+export function finiteNumber(value) {
+    const number = typeof value === 'string' ? numberFromText(value.trim()) : value;
+    return typeof number === 'number' && Number.isFinite(number) ? number : undefined;
+}
+function tilesDiffer(base, current) {
+    const ids = new Set([...Object.keys(base), ...Object.keys(current)].map(Number));
+    return [...ids].some((componentId) => tileStateKey(base[componentId]) !== tileStateKey(current[componentId]));
+}
+// One text for a stored group value, the same for every way of writing the
+// same filter: picks in any order, text trimmed, and an empty value read as
+// none.
+function storedValueKey(value) {
+    const stored = value ?? {};
+    const picks = (list) => [...(keptPicks(list) ?? [])].map(String).sort();
+    return JSON.stringify([
+        stored.relative ?? null,
+        stored.start?.slice(0, 10) ?? null,
+        stored.end?.slice(0, 10) ?? null,
+        picks(stored.values),
+        picks(stored.excludeValues),
+        (stored.value ?? '').trim(),
+        finiteNumber(stored.min) ?? null,
+        finiteNumber(stored.max) ?? null,
+    ]);
+}
+// One text for a tile's state, over the keys this viewer reads. No direction
+// reads as ascending, the way a list applies it.
+function tileStateKey(tile) {
+    return JSON.stringify([
+        tile?.sort?.column ? [tile.sort.column, tile.sort.direction ?? 'asc'] : null,
+        tile?.search ?? '',
+        [...(tile?.hidden ?? [])].sort(),
+        drillKey(tile?.drill),
+    ]);
+}
+function drillKey(path) {
+    return JSON.stringify((path ?? [])
+        .map((step) => [step.level, step.value === null || step.value === undefined ? null : String(step.value)]));
+}
+// The picks of a list with blanks (null, '') left out, or undefined when none
+// is left.
+function keptPicks(list) {
+    const kept = (list ?? []).filter((pick) => isSet(pick) && pick !== '');
+    return kept.length ? kept : undefined;
+}
+// Only the parts that hold something, or null when none does.
+function storedOrNull(value) {
+    const stored = Object.fromEntries(Object.entries(value).filter(([, part]) => isSet(part)));
+    return Object.keys(stored).length ? stored : null;
+}
+function isDrillValue(value) {
+    return value === null || typeof value === 'string' || typeof value === 'number';
+}
+function isSet(value) {
+    return value !== undefined && value !== null;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-state.js","sourceRoot":"","sources":["../../../../src/app/reports/report-state.ts"],"names":[],"mappings":"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","sourcesContent":["// The pure rules of the viewer's state (ReportStateSnapshot): the relative\n// ranges the server resolves, a group value in its stored shape, a chart's\n// drill path, and whether the screen still shows the report's defaults.\n// Pure, so the node harness runs them.\n//\n// - The state service turns its values into the stored shape\n//   (toStoredGroupValue) and asks stateDiffers whether the screen differs\n//   from the report's authored defaults.\n// - A drill path is kept to what a tile can carry (cleanDrillPath).\nimport { ReportDrillStep } from './interfaces/report-drill-step.interface';\nimport { ReportStateSnapshot } from './interfaces/report-state-snapshot.interface';\nimport { ReportTileState } from './interfaces/report-tile-state.interface';\nimport {\n  ChartGranularity,\n  FilterGroupDefault,\n  FilterGroupValue,\n  GRANULARITY_OPTIONS,\n  ReportFilterType,\n  ReportRelativeRange,\n} from './interfaces/report.interface';\nimport { dateBoundString } from './report-filter-items';\n\n\n// The server's cap on a drill path.\nexport const DRILL_MAX_DEPTH = 5;\n\n// Every relative range name the server knows, in its enum's order. A record\n// rather than a list, so the build fails when ReportRelativeRange gains a\n// name this misses.\nconst RELATIVE_RANGES: Record<ReportRelativeRange, true> = {\n  thisWeek: true,\n  lastWeek: true,\n  last7Days: true,\n  last30Days: true,\n  last3Months: true,\n  last6Months: true,\n  last12Months: true,\n  thisMonth: true,\n  thisQuarter: true,\n  thisYear: true,\n  yearToDate: true,\n};\n\n// The same names as a list, in the server enum's order (the record's key\n// order): the order the date picker offers them in.\nexport const RELATIVE_RANGE_NAMES = Object.keys(RELATIVE_RANGES) as ReportRelativeRange[];\n\nconst DAY_PATTERN = /^(\\d{4})-(\\d{2})-(\\d{2})$/;\n\n// A number as text: what a masked input sends.\nconst NUMBER_PATTERN = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i;\n\n\n// Whether a name is a relative range the server resolves.\nexport function isRelativeRange(name: unknown): name is ReportRelativeRange {\n  return typeof name === 'string' && Object.prototype.hasOwnProperty.call(RELATIVE_RANGES, name);\n}\n\nexport function isChartGranularity(value: unknown): value is ChartGranularity {\n  return GRANULARITY_OPTIONS.some((option) => option.value === value);\n}\n\n// Whether text is a real calendar day written 'yyyy-MM-dd' (no 2026-02-30).\nexport function isCalendarDay(text: string): boolean {\n  const parts = DAY_PATTERN.exec(text);\n  if (!parts) {\n    return false;\n  }\n\n  const [year, month, day] = parts.slice(1).map(Number);\n  const date = new Date(Date.UTC(year, month - 1, day));\n\n  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;\n}\n\n// A number written as text (a masked input's value), or null when the text\n// is not one finite number.\nexport function numberFromText(text: string): number | null {\n  const number = NUMBER_PATTERN.test(text) ? Number(text) : NaN;\n\n  return Number.isFinite(number) ? number : null;\n}\n\n// A group's value in its stored shape, read for the keys its group's type\n// owns, or null when it holds nothing. A date range that still carries its\n// relative preset is written as that preset whatever today is.\nexport function toStoredGroupValue(\n  type: ReportFilterType,\n  value: FilterGroupValue | null | undefined,\n): FilterGroupDefault | null {\n  if (!value) {\n    return null;\n  }\n\n  switch (type) {\n    case 'dateRange':\n      return isRelativeRange(value.preset)\n        ? { relative: value.preset }\n        : storedOrNull({ start: dateBoundString(value.start), end: dateBoundString(value.end) });\n\n    case 'select': {\n      const excludeValues = keptPicks(value.excludeValues);\n\n      return storedOrNull(excludeValues ? { excludeValues } : { values: keptPicks(value.values) });\n    }\n\n    case 'numberRange':\n      return storedOrNull({ min: finiteNumber(value.min), max: finiteNumber(value.max) });\n\n    default:\n      return storedOrNull({ value: value.value?.trim() || undefined });\n  }\n}\n\n// Whether the screen's state (`current`, a snapshot) differs from the\n// report's authored defaults (`defaults`): the match, the grain, a group's\n// value, or a tile's sort, search, hidden columns or drill path. The page is\n// not compared (moving to another page changes no filter). Picks are\n// compared in any order.\nexport function stateDiffers(defaults: ReportStateSnapshot, current: ReportStateSnapshot): boolean {\n  return (defaults.match ?? 'all') !== (current.match ?? 'all')\n    || (defaults.groupBy ?? null) !== (current.groupBy ?? null)\n    || Object.entries(current.groups ?? {})\n      .some(([groupId, value]) => storedValueKey(defaults.groups?.[Number(groupId)]) !== storedValueKey(value))\n    || tilesDiffer(defaults.tiles ?? {}, current.tiles ?? {});\n}\n\n// Whether two stored group values are the same filter: picks in any order,\n// text trimmed, an empty value read as none.\nexport function sameStoredGroupValue(\n  a: FilterGroupDefault | null | undefined,\n  b: FilterGroupDefault | null | undefined,\n): boolean {\n  return storedValueKey(a) === storedValueKey(b);\n}\n\n// A drill path kept to what a tile can carry: its steps up to the first that\n// is not a time level with a plain value (the steps before it are kept), at\n// most DRILL_MAX_DEPTH of them.\nexport function cleanDrillPath(path: readonly unknown[] | null | undefined): ReportDrillStep[] {\n  const kept: ReportDrillStep[] = [];\n\n  for (const step of path ?? []) {\n    if (!isPlainObject(step) || !isChartGranularity(step.level) || !isDrillValue(step.value)\n      || kept.length === DRILL_MAX_DEPTH) {\n      break;\n    }\n\n    kept.push({ level: step.level, value: step.value });\n  }\n\n  return kept;\n}\n\n// Whether two drill paths are the same steps. A value is compared as text,\n// so 2026 and '2026' are the same step.\nexport function sameDrillPath(\n  a: readonly ReportDrillStep[] | null | undefined,\n  b: readonly ReportDrillStep[] | null | undefined,\n): boolean {\n  return drillKey(a) === drillKey(b);\n}\n\n// A range end as a number. A masked input sends its number as text, so\n// numeric text is read as its number.\nexport function finiteNumber(value: unknown): number | undefined {\n  const number = typeof value === 'string' ? numberFromText(value.trim()) : value;\n\n  return typeof number === 'number' && Number.isFinite(number) ? number : undefined;\n}\n\nfunction tilesDiffer(base: Record<number, ReportTileState>, current: Record<number, ReportTileState>): boolean {\n  const ids = new Set([...Object.keys(base), ...Object.keys(current)].map(Number));\n\n  return [...ids].some((componentId) => tileStateKey(base[componentId]) !== tileStateKey(current[componentId]));\n}\n\n// One text for a stored group value, the same for every way of writing the\n// same filter: picks in any order, text trimmed, and an empty value read as\n// none.\nfunction storedValueKey(value: FilterGroupDefault | null | undefined): string {\n  const stored = value ?? {};\n  const picks = (list: unknown[] | undefined) => [...(keptPicks(list) ?? [])].map(String).sort();\n\n  return JSON.stringify([\n    stored.relative ?? null,\n    stored.start?.slice(0, 10) ?? null,\n    stored.end?.slice(0, 10) ?? null,\n    picks(stored.values),\n    picks(stored.excludeValues),\n    (stored.value ?? '').trim(),\n    finiteNumber(stored.min) ?? null,\n    finiteNumber(stored.max) ?? null,\n  ]);\n}\n\n// One text for a tile's state, over the keys this viewer reads. No direction\n// reads as ascending, the way a list applies it.\nfunction tileStateKey(tile: ReportTileState | undefined): string {\n  return JSON.stringify([\n    tile?.sort?.column ? [tile.sort.column, tile.sort.direction ?? 'asc'] : null,\n    tile?.search ?? '',\n    [...(tile?.hidden ?? [])].sort(),\n    drillKey(tile?.drill),\n  ]);\n}\n\nfunction drillKey(path: readonly ReportDrillStep[] | null | undefined): string {\n  return JSON.stringify((path ?? [])\n    .map((step) => [step.level, step.value === null || step.value === undefined ? null : String(step.value)]));\n}\n\n// The picks of a list with blanks (null, '') left out, or undefined when none\n// is left.\nfunction keptPicks(list: unknown[] | null | undefined): unknown[] | undefined {\n  const kept = (list ?? []).filter((pick) => isSet(pick) && pick !== '');\n\n  return kept.length ? kept : undefined;\n}\n\n// Only the parts that hold something, or null when none does.\nfunction storedOrNull(value: Record<string, unknown>): FilterGroupDefault | null {\n  const stored = Object.fromEntries(Object.entries(value).filter(([, part]) => isSet(part))) as FilterGroupDefault;\n\n  return Object.keys(stored).length ? stored : null;\n}\n\nfunction isDrillValue(value: unknown): value is ReportDrillStep['value'] {\n  return value === null || typeof value === 'string' || typeof value === 'number';\n}\n\nfunction isSet(value: unknown): boolean {\n  return value !== undefined && value !== null;\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n"]}

package/esm2022/app/reports/report-viewer-features.mjs

@@ -10,8 +10,7 @@
 // numberRange its min/max control, matchAny the report bar's Match select,
 // and pageScope shows a page's groups in the report bar of that page.
 // cascadingOptions narrows a select's list by the other filters of its tile
-// (ReportFilterOptionsService). views is the Views picker in the report's
-// header (ReportViewPickerComponent). drill is a time chart's click down, with
+// (ReportFilterOptionsService). drill is a time chart's click down, with
 // the tile header's breadcrumb and its menu's Drill up and Back to top as the
 // way back.
 export const VIEWER_FEATURES = [
@@ -21,7 +20,6 @@ export const VIEWER_FEATURES = [
     'matchAny',
     'pageScope',
     'cascadingOptions',
-    'views',
     'drill',
 ];
 // The features a report offers on this screen: the ones its server serves
@@ -39,4 +37,4 @@ export function offersExclude(group, features) {
         && !group.multiColumn
         && (features ?? []).includes('excludeValues');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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