@antelopejs/dms 0.5.6 → 0.6.0

package/frontend-vue/layers/dms-core/app/build/composables/auth/usePermissionPreview.ts

@@ -0,0 +1,297 @@
+import {
+  buildPreviewUrl,
+  isPreviewEntryLocked,
+  isStalePreviewSession,
+  parsePreviewSession,
+  PERMISSION_PREVIEW_ENDPOINT,
+  PERMISSION_PREVIEW_QUERY_KEY,
+  PERMISSION_PREVIEW_STORAGE_PREFIX,
+  PERMISSION_PREVIEW_TAB_KEY,
+  type PermissionPreviewBlock,
+  type PermissionPreviewResult,
+  type PermissionPreviewSession,
+  type PreviewEntryState,
+  resolveActivePreviewBlock,
+  resolvePreviewEntryState,
+} from "../../utils/permission-preview";
+
+/** What the roles editor hands over when it opens a preview. */
+export type PermissionPreviewInput = Omit<
+  PermissionPreviewSession,
+  "id" | "updatedAt"
+>;
+
+const CLOSE_FALLBACK_DELAY_MS = 150;
+
+function storageKey(id: string): string {
+  return `${PERMISSION_PREVIEW_STORAGE_PREFIX}${id}`;
+}
+
+function readStorage(storage: Storage, key: string): string | null {
+  try {
+    return storage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+function writeStorage(storage: Storage, key: string, value: string): void {
+  try {
+    storage.setItem(key, value);
+  } catch {
+    /* storage unavailable (private mode, quota): the preview tab finds nothing */
+  }
+}
+
+function removeStorage(storage: Storage, key: string): void {
+  try {
+    storage.removeItem(key);
+  } catch {
+    /* noop */
+  }
+}
+
+function removeSessions(isRemoved: (key: string) => boolean): void {
+  try {
+    for (let index = localStorage.length - 1; index >= 0; index--) {
+      const key = localStorage.key(index);
+      if (!key?.startsWith(PERMISSION_PREVIEW_STORAGE_PREFIX)) continue;
+      if (isRemoved(key)) removeStorage(localStorage, key);
+    }
+  } catch {
+    /* noop */
+  }
+}
+
+// Sessions left behind by tabs closed without "Exit preview".
+function pruneStaleSessions(now: number): void {
+  removeSessions((key) => {
+    const session = parsePreviewSession(readStorage(localStorage, key));
+    return !session || isStalePreviewSession(session, now);
+  });
+}
+
+function newPreviewId(): string {
+  return typeof crypto !== "undefined" && "randomUUID" in crypto
+    ? crypto.randomUUID()
+    : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}
+
+// Only the latest preview request may land: the route and the edits both move.
+let refreshGeneration = 0;
+
+function usePreviewState() {
+  return {
+    session: useDmsState<PermissionPreviewSession | null>(
+      "dms-permission-preview-session",
+      () => null,
+    ),
+    result: useDmsState<PermissionPreviewResult | null>(
+      "dms-permission-preview-result",
+      () => null,
+    ),
+    loading: useDmsState<boolean>(
+      "dms-permission-preview-loading",
+      () => false,
+    ),
+    failed: useDmsState<boolean>("dms-permission-preview-failed", () => false),
+  };
+}
+
+/**
+ * "Preview as role": the roles editor opens a tab that browses the real
+ * dashboard as a role would see it — its unsaved edits included. The server
+ * says what the role would lose on the menu and on the current page; the tab
+ * veils those blocks instead of removing them.
+ *
+ * The session's permissions never change: the tab keeps the viewer's own
+ * access, and the preview only ever annotates what the viewer is served. An
+ * action taken in the tab runs with those real rights, as anywhere else.
+ */
+export function usePermissionPreview() {
+  const state = usePreviewState();
+  const isActive = computed(() => state.session.value !== null);
+  const hiddenEntries = computed(
+    () => new Set(state.result.value?.hiddenEntries ?? []),
+  );
+  const partialEntries = computed(
+    () => new Set(state.result.value?.partialEntries ?? []),
+  );
+  const hiddenHeaderActions = computed(
+    () => new Set(state.result.value?.hiddenHeaderActions ?? []),
+  );
+  const hiddenQuickActions = computed(
+    () => new Set(state.result.value?.hiddenQuickActions ?? []),
+  );
+
+  function blockFor(
+    layoutPath: string | undefined,
+  ): PermissionPreviewBlock | undefined {
+    return resolveActivePreviewBlock(
+      isActive.value,
+      state.result.value,
+      layoutPath,
+    );
+  }
+
+  function isEntryHidden(fullId: string | undefined): boolean {
+    return isPreviewEntryLocked(isActive.value, hiddenEntries.value, fullId);
+  }
+
+  /**
+   * How a menu entry, settings item or overview card is drawn: `hidden` when
+   * the role could not open it, `partial` when it opens it without some of
+   * its blocks, actions or entries. Always `null` outside a preview.
+   */
+  function entryState(fullId: string | undefined): PreviewEntryState | null {
+    return resolvePreviewEntryState(
+      isActive.value,
+      hiddenEntries.value,
+      partialEntries.value,
+      fullId,
+    );
+  }
+
+  /** Whether a header action of the current page is drawn locked. */
+  function isHeaderActionHidden(id: string | undefined): boolean {
+    return isPreviewEntryLocked(isActive.value, hiddenHeaderActions.value, id);
+  }
+
+  /** Whether a quick action (`category:id`) is drawn locked. */
+  function isQuickActionHidden(key: string | undefined): boolean {
+    return isPreviewEntryLocked(isActive.value, hiddenQuickActions.value, key);
+  }
+
+  function share(id: string, input: PermissionPreviewInput): void {
+    const session: PermissionPreviewSession = {
+      ...input,
+      id,
+      updatedAt: Date.now(),
+    };
+    writeStorage(localStorage, storageKey(id), JSON.stringify(session));
+  }
+
+  /** Open a preview tab on `path`; returns the id to keep it in sync. */
+  function start(input: PermissionPreviewInput, path: string): string {
+    pruneStaleSessions(Date.now());
+    const id = newPreviewId();
+    share(id, input);
+    window.open(buildPreviewUrl(path, id), "_blank");
+    return id;
+  }
+
+  /** Push the editor's latest edits to an open preview tab. */
+  function update(id: string, input: PermissionPreviewInput): void {
+    if (readStorage(localStorage, storageKey(id)) === null) return;
+    share(id, input);
+  }
+
+  function readSession(id: string): PermissionPreviewSession | null {
+    const session = parsePreviewSession(
+      readStorage(localStorage, storageKey(id)),
+    );
+    return session && session.id === id ? session : null;
+  }
+
+  function takeIdFromLocation(): string | null {
+    const url = new URL(window.location.href);
+    const id = url.searchParams.get(PERMISSION_PREVIEW_QUERY_KEY);
+    if (!id) return null;
+    url.searchParams.delete(PERMISSION_PREVIEW_QUERY_KEY);
+    window.history.replaceState(window.history.state, "", url.href);
+    return id;
+  }
+
+  /**
+   * Turn this tab into a preview when it was opened as one (or reloaded while
+   * being one). Returns whether it did.
+   */
+  function activate(): boolean {
+    const id =
+      takeIdFromLocation() ??
+      readStorage(sessionStorage, PERMISSION_PREVIEW_TAB_KEY);
+    if (!id) return false;
+    const session = readSession(id);
+    if (!session) {
+      removeStorage(sessionStorage, PERMISSION_PREVIEW_TAB_KEY);
+      return false;
+    }
+    writeStorage(sessionStorage, PERMISSION_PREVIEW_TAB_KEY, id);
+    state.session.value = session;
+    window.addEventListener("storage", (event) => {
+      if (event.key !== storageKey(id) || !state.session.value) return;
+      const next = parsePreviewSession(event.newValue);
+      if (next) state.session.value = next;
+    });
+    return true;
+  }
+
+  /** Ask the server what the role changes on the menu and on `path`. */
+  async function refresh(path: string): Promise<void> {
+    const session = state.session.value;
+    if (!session) return;
+    const current = ++refreshGeneration;
+    state.loading.value = true;
+    try {
+      const { $authFetch } = useAuthFetch();
+      const result = await $authFetch<PermissionPreviewResult>(
+        PERMISSION_PREVIEW_ENDPOINT,
+        { method: "POST", body: { permissions: session.permissions, path } },
+      );
+      if (current !== refreshGeneration) return;
+      state.result.value = result;
+      state.failed.value = false;
+    } catch {
+      if (current !== refreshGeneration) return;
+      state.failed.value = true;
+    } finally {
+      if (current === refreshGeneration) state.loading.value = false;
+    }
+  }
+
+  /** Leave the preview: close the tab it opened, or go back to the editor. */
+  function exit(): void {
+    const session = state.session.value;
+    state.session.value = null;
+    state.result.value = null;
+    removeStorage(sessionStorage, PERMISSION_PREVIEW_TAB_KEY);
+    if (!session) return;
+    removeStorage(localStorage, storageKey(session.id));
+    window.close();
+    // Still open: the tab was not opened by the editor (a reload in a new
+    // window, a copied URL), so it cannot close itself.
+    setTimeout(() => {
+      void navigateDms(session.returnTo);
+    }, CLOSE_FALLBACK_DELAY_MS);
+  }
+
+  /**
+   * Forget every preview this browser holds, on sign-out: the next account to
+   * sign in here must not find the previous one's role and drafts.
+   */
+  function purge(): void {
+    state.session.value = null;
+    state.result.value = null;
+    removeStorage(sessionStorage, PERMISSION_PREVIEW_TAB_KEY);
+    removeSessions(() => true);
+  }
+
+  return {
+    session: state.session,
+    result: state.result,
+    loading: state.loading,
+    failed: state.failed,
+    isActive,
+    blockFor,
+    isEntryHidden,
+    entryState,
+    isHeaderActionHidden,
+    isQuickActionHidden,
+    start,
+    update,
+    activate,
+    refresh,
+    exit,
+    purge,
+  };
+}

package/frontend-vue/layers/dms-core/app/build/composables/page/usePageRecordLabel.ts

@@ -0,0 +1,31 @@
+import { computed } from "vue";
+
+interface PageRecordLabel {
+  path: string;
+  label: string;
+}
+
+const STATE_KEY = "dms-page-record-label";
+
+/**
+ * The label of the row a page is about, e.g. the task an edit page changes:
+ * the form that loads the row sets it, the breadcrumb ends with it. Held with
+ * the page's path, so it never outlives its page.
+ */
+export function usePageRecordLabel() {
+  const state = useDmsState<PageRecordLabel | null>(STATE_KEY, () => null);
+  const route = useDmsRoute();
+
+  const label = computed(() =>
+    state.value && state.value.path === route.path
+      ? state.value.label
+      : undefined,
+  );
+
+  /** Names the row of the page at `path`; no label clears it. */
+  const setLabel = (path: string, value: string | undefined) => {
+    state.value = value ? { path, label: value } : null;
+  };
+
+  return { label, setLabel };
+}

package/frontend-vue/layers/dms-core/app/build/utils/permission-preview.ts

@@ -0,0 +1,266 @@
+// "Preview as role" (roles editor): the shapes the preview endpoint answers
+// with, how a preview session travels from the editor tab to the preview tab,
+// and which requests a preview tab may still send. Pure: no Vue, no window.
+
+/** What a preview does to one block (`packages/dms/src/pages/settings/users/role-preview.ts`). */
+export type PermissionPreviewBlock =
+  | { state: "hidden" }
+  | { state: "readonly" | "limited"; withheld: string[] };
+
+export type PermissionPreviewState = PermissionPreviewBlock["state"];
+
+/** Answer of `POST /settings/workspace/roles/preview`. */
+export interface PermissionPreviewResult {
+  page: { fullId: string; displayName: string; hidden: boolean } | null;
+  /** Blocks keyed by layout path (component key, then child ids). */
+  blocks: Record<string, PermissionPreviewBlock>;
+  /** Menu entries (`fullId`) the viewer reaches and the role would not. */
+  hiddenEntries: string[];
+  /**
+   * Menu entries (`fullId`) the role opens without all the viewer has there:
+   * a page losing a block or an action, a group holding a refused or partial
+   * entry. Absent from servers predating partial access.
+   */
+  partialEntries?: string[];
+  /** Header actions of the page (ids) the viewer is shown and the role would not be. */
+  hiddenHeaderActions?: string[];
+  /** Quick actions (`category:id`) the viewer is served and the role would not be. */
+  hiddenQuickActions?: string[];
+  /** Role permissions outside the viewer's own access, left out of the preview. */
+  outOfScope: number;
+}
+
+/** A role as the editor hands it to the preview tab, unsaved edits included. */
+export interface PermissionPreviewSession {
+  id: string;
+  roleId: string | null;
+  roleName: string;
+  permissions: string[];
+  /** Whether the editor holds edits that are not saved yet. */
+  unsaved: boolean;
+  /** Where "Exit preview" leads when the tab cannot close itself. */
+  returnTo: string;
+  updatedAt: number;
+}
+
+/** Endpoint the preview tab asks; a POST, so the request guard lets it through. */
+export const PERMISSION_PREVIEW_ENDPOINT = "/settings/workspace/roles/preview";
+/** Query parameter that hands a preview session to a new tab. */
+export const PERMISSION_PREVIEW_QUERY_KEY = "dms-preview";
+/** `localStorage` key prefix of the sessions the editor shares with its preview tabs. */
+export const PERMISSION_PREVIEW_STORAGE_PREFIX = "dms-role-preview:";
+/** `sessionStorage` key holding the preview of the current tab across reloads. */
+export const PERMISSION_PREVIEW_TAB_KEY = "dms-role-preview-id";
+/** Sessions older than this are dropped the next time a preview starts. */
+export const PERMISSION_PREVIEW_TTL_MS = 86_400_000;
+/**
+ * Attribute the pre-paint script puts on `<html>` while a reloaded preview
+ * tab has not applied its preview yet: the page content gives way to its
+ * skeleton and the preview bar's place is held, so the full page never shows
+ * before its veils.
+ */
+export const PERMISSION_PREVIEW_PENDING_ATTRIBUTE = "data-dms-role-preview";
+
+function isStringArray(value: unknown): value is string[] {
+  return (
+    Array.isArray(value) && value.every((item) => typeof item === "string")
+  );
+}
+
+/** A stored preview session, or `null` when the value is not one. */
+export function parsePreviewSession(
+  raw: string | null,
+): PermissionPreviewSession | null {
+  if (!raw) return null;
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const session = value as Partial<PermissionPreviewSession>;
+  if (
+    typeof session.id !== "string" ||
+    typeof session.roleName !== "string" ||
+    !isStringArray(session.permissions) ||
+    typeof session.returnTo !== "string" ||
+    typeof session.updatedAt !== "number"
+  ) {
+    return null;
+  }
+  return {
+    id: session.id,
+    roleId: typeof session.roleId === "string" ? session.roleId : null,
+    roleName: session.roleName,
+    permissions: session.permissions,
+    unsaved: session.unsaved === true,
+    returnTo: session.returnTo,
+    updatedAt: session.updatedAt,
+  };
+}
+
+export function isStalePreviewSession(
+  session: Pick<PermissionPreviewSession, "updatedAt">,
+  now: number,
+): boolean {
+  return now - session.updatedAt > PERMISSION_PREVIEW_TTL_MS;
+}
+
+/** Layout path of a child block: its parent's path, then its own id. */
+export function childLayoutPath(
+  parentPath: string | undefined,
+  childId: string,
+): string | undefined {
+  return parentPath ? `${parentPath}.${childId}` : undefined;
+}
+
+/** The preview state of a block, when the preview changes it. */
+export function resolvePreviewBlock(
+  result: PermissionPreviewResult | null | undefined,
+  layoutPath: string | undefined,
+): PermissionPreviewBlock | undefined {
+  if (!result || !layoutPath) return undefined;
+  return result.blocks[layoutPath];
+}
+
+/**
+ * The veil of a block. Only a running preview veils anything: a normal session
+ * is served what its permissions allow, with nothing locked or veiled.
+ */
+export function resolveActivePreviewBlock(
+  active: boolean,
+  result: PermissionPreviewResult | null | undefined,
+  layoutPath: string | undefined,
+): PermissionPreviewBlock | undefined {
+  return active ? resolvePreviewBlock(result, layoutPath) : undefined;
+}
+
+/**
+ * Whether a menu entry (registered page or category, label, dynamic entry or
+ * footer link, by its `fullId`) is drawn locked: only while a preview runs,
+ * for an entry the previewed role could not open.
+ */
+export function isPreviewEntryLocked(
+  active: boolean,
+  hiddenEntries: ReadonlySet<string>,
+  fullId: string | undefined,
+): boolean {
+  return active && !!fullId && hiddenEntries.has(fullId);
+}
+
+/**
+ * How a menu entry is drawn during a preview: `hidden` (red hatch and lock)
+ * when the role could not open it, `partial` (orange hatch and lock) when it
+ * opens it but loses a block, an action or an entry inside.
+ */
+export type PreviewEntryState = "hidden" | "partial";
+
+/**
+ * The preview state of a menu entry, settings item or overview card (by its
+ * `fullId`). Only while a preview runs: a normal session never draws either.
+ * A refused entry is never also partial.
+ */
+export function resolvePreviewEntryState(
+  active: boolean,
+  hiddenEntries: ReadonlySet<string>,
+  partialEntries: ReadonlySet<string>,
+  fullId: string | undefined,
+): PreviewEntryState | null {
+  if (!active || !fullId) return null;
+  if (hiddenEntries.has(fullId)) return "hidden";
+  if (partialEntries.has(fullId)) return "partial";
+  return null;
+}
+
+/** The key a quick action is served under: `category:id`. */
+export function quickActionKey(action: {
+  id: string;
+  category: { id: string };
+}): string {
+  return `${action.category.id}:${action.id}`;
+}
+
+/**
+ * What `applyPreviewLocks` reads from a menu entry. Children are walked as
+ * entries of the same kind (Nuxt UI types them as child items, which carry the
+ * same `fullId` at runtime).
+ */
+export interface PreviewLockableEntry {
+  fullId?: string;
+  children?: readonly object[];
+}
+
+/**
+ * Walk a menu (top-level groups of entries, their children at any depth) and
+ * pass each entry the preview locks to `lock`. Labels, collapsed groups and
+ * nested entries are all visited; an entry without a `fullId` is left as is.
+ */
+export function applyPreviewLocks<T extends PreviewLockableEntry>(
+  items: readonly T[],
+  isLocked: (fullId: string | undefined) => boolean,
+  lock: (item: T) => T,
+): T[] {
+  return applyPreviewEntryStates(
+    items,
+    (fullId) => (isLocked(fullId) ? "hidden" : null),
+    lock,
+  );
+}
+
+/**
+ * Walk a menu like `applyPreviewLocks`, passing each entry with a preview
+ * state (refused or partial) to `decorate` along with that state.
+ */
+export function applyPreviewEntryStates<T extends PreviewLockableEntry>(
+  items: readonly T[],
+  stateOf: (fullId: string | undefined) => PreviewEntryState | null,
+  decorate: (item: T, state: PreviewEntryState) => T,
+): T[] {
+  return items.map((item) => {
+    const children = item.children
+      ? applyPreviewEntryStates(
+          item.children as readonly T[],
+          stateOf,
+          decorate,
+        )
+      : undefined;
+    const visited = children ? { ...item, children } : item;
+    const state = stateOf(item.fullId);
+    return state ? decorate(visited, state) : visited;
+  });
+}
+
+/** Query string of a preview tab's first URL. */
+export function buildPreviewUrl(path: string, id: string): string {
+  const separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}${PERMISSION_PREVIEW_QUERY_KEY}=${encodeURIComponent(id)}`;
+}
+
+/** What the page picker of a preview reads from a site layout page. */
+export interface PreviewablePageSource {
+  hasAccess?: boolean;
+  hidden?: boolean;
+  publicAccess?: boolean;
+  validation?: { requiredQueryParams?: string[] };
+}
+
+/**
+ * Pages a preview can switch to: those the viewer opens without parameters.
+ * Public pages (sign-in screens) and pages kept out of the menu are left out;
+ * a page needing a route or query parameter is reached by navigating instead.
+ */
+export function listPreviewablePages<T extends PreviewablePageSource>(
+  pages: Record<string, T>,
+): Array<{ slug: string; page: T }> {
+  return Object.entries(pages)
+    .filter(
+      ([slug, page]) =>
+        page.hasAccess !== false &&
+        page.hidden !== true &&
+        page.publicAccess !== true &&
+        !slug.includes(":") &&
+        (page.validation?.requiredQueryParams?.length ?? 0) === 0,
+    )
+    .map(([slug, page]) => ({ slug, page }));
+}

package/frontend-vue/layers/dms-core/app/composables/data-types/useDataType.ts

@@ -2,10 +2,20 @@ import type { Component } from "vue";
 
 export type RecordWithDefault<T> = Record<string, T> & { default: T };
 
+/**
+ * Turns a value into its display. `row` is the whole listed row when the value
+ * is drawn in a table (cell, detail band), so a formatter can compose sibling
+ * fields; it is absent elsewhere (forms, filters) and must be optional.
+ *
+ * Keys of a data type's `formatter` record: `default` (required), `cell` (a
+ * shorter grid rendering), `empty` (drawn instead of the fallback for a
+ * null/undefined value), and one per compare mode for filter chips.
+ */
 export type DataTypeFormatter = (
   value: unknown,
   locale: string,
   options?: unknown,
+  row?: Record<string, unknown>,
 ) => unknown;
 
 /**
@@ -15,10 +25,27 @@ export type DataTypeFormatter = (
  */
 export type BeforeStateMapper = (value: unknown, options?: unknown) => unknown;
 
+/**
+ * Whether two values of a data type are the same value, whatever shape each
+ * comes in: a form compares the value it loaded from the server with the one
+ * its control holds through it, to tell an edited field from an untouched one.
+ */
+export type DataTypeValueComparer = (
+  left: unknown,
+  right: unknown,
+  options?: unknown,
+) => boolean;
+
 export interface DataType {
   id: string;
   formatter?: RecordWithDefault<DataTypeFormatter>;
   beforeStateMapper?: BeforeStateMapper;
+  /**
+   * How two values of the type compare, for a type whose server value and
+   * form state differ in shape (a relation loaded as its row, held as its id)
+   * or whose order does not count. Without it, values compare deeply.
+   */
+  isSameValue?: DataTypeValueComparer;
   displayComponent?: Component;
 }
 const dataTypes: Record<string, DataType> = {};

package/frontend-vue/layers/dms-core/app/composables/period/compareResolvers.ts

@@ -2,7 +2,39 @@ import type { PeriodComparison, PeriodRange } from "./types";
 
 const NON_OVERLAP_GAP_MS = 1;
 
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+function isLocalMidnight(date: Date): boolean {
+  return (
+    date.getHours() === 0 &&
+    date.getMinutes() === 0 &&
+    date.getSeconds() === 0 &&
+    date.getMilliseconds() === 0
+  );
+}
+
+/** A range of whole local days: midnight to the last millisecond of a day. */
+function isWholeDayRange(range: PeriodRange): boolean {
+  return (
+    isLocalMidnight(range.from) &&
+    isLocalMidnight(new Date(range.to.getTime() + NON_OVERLAP_GAP_MS))
+  );
+}
+
 function shiftPreviousPeriod(range: PeriodRange): PeriodRange {
+  // Whole-day ranges move by calendar days, so a span crossing a daylight
+  // saving change still starts at midnight (a fixed-ms shift lands an hour off).
+  if (isWholeDayRange(range)) {
+    const end = range.to.getTime() + NON_OVERLAP_GAP_MS;
+    const days = Math.round((end - range.from.getTime()) / MS_PER_DAY);
+    const from = new Date(range.from);
+    from.setDate(from.getDate() - days);
+    return {
+      from,
+      to: new Date(range.from.getTime() - NON_OVERLAP_GAP_MS),
+    };
+  }
+
   const duration = range.to.getTime() - range.from.getTime();
   const shiftMs = duration + NON_OVERLAP_GAP_MS;
   return {
@@ -31,7 +63,9 @@ const COMPARISON_RESOLVERS: Record<
  * Resolves the range a period is compared against.
  *
  * `previous-period` returns the equal-length span immediately before the
- * range, offset by a single millisecond so the two never overlap.
+ * range, offset by a single millisecond so the two never overlap. Ranges of
+ * whole days are measured in calendar days, so daylight saving changes don't
+ * move their midnight boundaries.
  */
 export function resolveComparisonRange(
   comparison: PeriodComparison,