@pilotiq/pilotiq 0.24.1 → 0.24.3

package/src/elements/TableGroup.test.ts

@@ -1,260 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { TableGroup, bucketDateValue, formatDateBucketTitle, orderByKeys } from './TableGroup.js'
-
-describe('TableGroup', () => {
-  describe('fluent setters', () => {
-    it('label() round-trips on toMeta()', () => {
-      const meta = TableGroup.make('status').label('Status').toMeta()
-      assert.equal(meta.column, 'status')
-      assert.equal(meta.label, 'Status')
-    })
-
-    it('falls back to column name when no label is set', () => {
-      const meta = TableGroup.make('author_id').toMeta()
-      assert.equal(meta.label, 'author_id')
-    })
-
-    it('collapsible() flips the meta flag', () => {
-      assert.equal(TableGroup.make('s').toMeta().collapsible, undefined)
-      assert.equal(TableGroup.make('s').collapsible().toMeta().collapsible, true)
-      assert.equal(TableGroup.make('s').collapsible(false).toMeta().collapsible, undefined)
-    })
-
-    it('collapsed() flips the meta flag', () => {
-      assert.equal(TableGroup.make('s').toMeta().collapsed, undefined)
-      assert.equal(TableGroup.make('s').collapsed().toMeta().collapsed, true)
-      assert.equal(TableGroup.make('s').collapsed(false).toMeta().collapsed, undefined)
-    })
-
-    it('date() flips the meta flag', () => {
-      assert.equal(TableGroup.make('createdAt').toMeta().date, undefined)
-      assert.equal(TableGroup.make('createdAt').date().toMeta().date, true)
-    })
-
-    it('chains multiple setters', () => {
-      const meta = TableGroup.make('status')
-        .label('Status')
-        .collapsible()
-        .collapsed()
-        .toMeta()
-      assert.deepEqual(meta, {
-        column:      'status',
-        label:       'Status',
-        collapsible: true,
-        collapsed:   true,
-      })
-    })
-  })
-
-  describe('record-derived title + description', () => {
-    it('getTitleHandler is invoked with the full record', () => {
-      const g = TableGroup.make<{ status: string }>('status')
-        .getTitleFromRecordUsing(r => r.status === 'draft' ? 'Drafts' : 'Published')
-      const fn = g.getTitleHandler()!
-      assert.equal(fn({ status: 'draft' }), 'Drafts')
-      assert.equal(fn({ status: 'live'  }), 'Published')
-    })
-
-    it('getDescriptionHandler is invoked with the full record', () => {
-      const g = TableGroup.make<{ count: number }>('status')
-        .getDescriptionFromRecordUsing(r => `${r.count} records`)
-      const fn = g.getDescriptionHandler()!
-      assert.equal(fn({ count: 12 }), '12 records')
-    })
-  })
-
-  describe('bucketDateValue', () => {
-    it('buckets ISO strings to YYYY-MM-DD', () => {
-      assert.equal(bucketDateValue('2026-05-04T13:24:00.000Z'), '2026-05-04')
-    })
-
-    it('buckets Date instances', () => {
-      assert.equal(bucketDateValue(new Date(Date.UTC(2026, 0, 9))), '2026-01-09')
-    })
-
-    it('buckets epoch numbers', () => {
-      assert.equal(bucketDateValue(0), '1970-01-01')
-    })
-
-    it('returns empty string for null/undefined/empty', () => {
-      assert.equal(bucketDateValue(null),      '')
-      assert.equal(bucketDateValue(undefined), '')
-      assert.equal(bucketDateValue(''),        '')
-    })
-
-    it('returns empty string for unparseable inputs', () => {
-      assert.equal(bucketDateValue('not a date'), '')
-    })
-  })
-
-  describe('orderUsing + orderByKeys', () => {
-    it('default — comparator unset', () => {
-      const g = TableGroup.make('status')
-      assert.equal(g.getKeyComparator(), undefined)
-    })
-
-    it('orderUsing() stores the comparator', () => {
-      const cmp = (a: string, b: string): number => a.length - b.length
-      const g = TableGroup.make('status').orderUsing(cmp)
-      assert.equal(g.getKeyComparator(), cmp)
-    })
-
-    it('orderByKeys ranks listed keys in order', () => {
-      const cmp = orderByKeys(['draft', 'published', 'archived'])
-      // Listed keys come back in declaration order, regardless of input.
-      const sorted = ['archived', 'draft', 'published'].slice().sort(cmp)
-      assert.deepEqual(sorted, ['draft', 'published', 'archived'])
-    })
-
-    it('orderByKeys puts unknown keys after the listed ones', () => {
-      const cmp = orderByKeys(['draft', 'published'])
-      // 'pending' isn't in the list — must sort after both listed keys.
-      const sorted = ['pending', 'draft', 'published'].slice().sort(cmp)
-      assert.deepEqual(sorted, ['draft', 'published', 'pending'])
-    })
-
-    it('orderByKeys breaks ties between unlisted keys alphabetically', () => {
-      const cmp = orderByKeys(['draft'])
-      const sorted = ['zeta', 'alpha', 'draft', 'beta'].slice().sort(cmp)
-      assert.deepEqual(sorted, ['draft', 'alpha', 'beta', 'zeta'])
-    })
-
-    it('orderByKeys empty list collapses to alphabetic', () => {
-      const cmp = orderByKeys([])
-      const sorted = ['c', 'a', 'b'].slice().sort(cmp)
-      assert.deepEqual(sorted, ['a', 'b', 'c'])
-    })
-  })
-
-  describe('formatDateBucketTitle', () => {
-    it('formats a parseable date as locale text', () => {
-      // We don't pin to an exact locale string — just confirm it's
-      // human-readable and contains the year.
-      const out = formatDateBucketTitle('2026-05-04T00:00:00.000Z')
-      assert.match(out, /2026/)
-      assert.match(out, /May/)
-    })
-
-    it('returns empty string for null/empty', () => {
-      assert.equal(formatDateBucketTitle(null), '')
-      assert.equal(formatDateBucketTitle(''),   '')
-    })
-
-    it('returns the raw value for unparseable inputs', () => {
-      assert.equal(formatDateBucketTitle('blob'), 'blob')
-    })
-  })
-
-  describe('scopable + scopeQueryByKey + getKeyFromRecordUsing', () => {
-    it('default — not scopable, no meta emit', () => {
-      assert.equal(TableGroup.make('status').isScopable(), false)
-      assert.equal(TableGroup.make('status').toMeta().scopable, undefined)
-    })
-
-    it('scopable() flips the meta flag', () => {
-      assert.equal(TableGroup.make('s').scopable().toMeta().scopable, true)
-      assert.equal(TableGroup.make('s').scopable(false).toMeta().scopable, undefined)
-    })
-
-    it('scopeQueryByKey() auto-arms scopable', () => {
-      const g = TableGroup.make('status').scopeQueryByKey((q, _k) => q)
-      assert.equal(g.isScopable(), true)
-      assert.equal(g.toMeta().scopable, true)
-    })
-
-    it('getKeyFromRecordUsing() auto-arms scopable', () => {
-      const g = TableGroup.make<{ s: string }>('status')
-        .getKeyFromRecordUsing(r => r.s.toUpperCase())
-      assert.equal(g.isScopable(), true)
-    })
-
-    it('scopable(false) after auto-arm opts back out', () => {
-      const g = TableGroup.make('status').scopeQueryByKey((q, _k) => q).scopable(false)
-      assert.equal(g.isScopable(), false)
-      assert.equal(g.toMeta().scopable, undefined)
-    })
-  })
-
-  describe('resolveKey', () => {
-    it('default — raw column value as string', () => {
-      const g = TableGroup.make('status')
-      assert.equal(g.resolveKey({ status: 'draft' }), 'draft')
-      assert.equal(g.resolveKey({ status: 42 }),      '42')
-    })
-
-    it('empty / null collapses to ""', () => {
-      const g = TableGroup.make('status')
-      assert.equal(g.resolveKey({ status: null }),      '')
-      assert.equal(g.resolveKey({ status: undefined }), '')
-      assert.equal(g.resolveKey({ status: '' }),        '')
-    })
-
-    it('date() returns the YYYY-MM-DD bucket', () => {
-      const g = TableGroup.make('createdAt').date()
-      assert.equal(g.resolveKey({ createdAt: '2026-05-04T12:00:00.000Z' }), '2026-05-04')
-    })
-
-    it('user handler wins', () => {
-      const g = TableGroup.make<{ s: string }>('status')
-        .getKeyFromRecordUsing(r => `K_${r.s}`)
-      assert.equal(g.resolveKey({ s: 'a' }), 'K_a')
-    })
-
-    it('handler returning undefined collapses to ""', () => {
-      const g = TableGroup.make<{ s: string | undefined }>('status')
-        .getKeyFromRecordUsing(r => r.s)
-      assert.equal(g.resolveKey({ s: undefined }), '')
-    })
-
-    it('throwing handler fails soft to ""', () => {
-      const g = TableGroup.make('status')
-        .getKeyFromRecordUsing(() => { throw new Error('boom') })
-      assert.equal(g.resolveKey({ status: 'draft' }), '')
-    })
-  })
-
-  describe('resolveScoper defaults', () => {
-    it('plain group — exact match where(col, "=", key)', () => {
-      const calls: Array<[string, string, unknown]> = []
-      const q = { where: (col: string, op: string, val: unknown) => { calls.push([col, op, val]); return q } }
-      const g = TableGroup.make('status')
-      const scoper = g.resolveScoper<typeof q>()
-      scoper(q, 'draft')
-      assert.deepEqual(calls, [['status', '=', 'draft']])
-    })
-
-    it('date group — whole-day range', () => {
-      const calls: Array<[string, string, unknown]> = []
-      const q = { where: (col: string, op: string, val: unknown) => { calls.push([col, op, val]); return q } }
-      const g = TableGroup.make('createdAt').date()
-      const scoper = g.resolveScoper<typeof q>()
-      scoper(q, '2026-05-04')
-      assert.deepEqual(calls, [
-        ['createdAt', '>=', '2026-05-04 00:00:00'],
-        ['createdAt', '<=', '2026-05-04 23:59:59'],
-      ])
-    })
-
-    it('date group — empty key is a no-op (no where call)', () => {
-      let calls = 0
-      const q = { where: (..._args: unknown[]) => { calls++; return q } }
-      const g = TableGroup.make('createdAt').date()
-      const scoper = g.resolveScoper<typeof q>()
-      scoper(q, '')
-      assert.equal(calls, 0)
-    })
-
-    it('user scoper wins over date() default', () => {
-      const calls: string[] = []
-      const q = { where: (col: string, op: string, val: unknown) => { calls.push(`${col} ${op} ${val}`); return q } }
-      const g = TableGroup.make<unknown>('createdAt')
-        .date()
-        .scopeQueryByKey<typeof q>((qq, key) => qq.where('createdAt', '=', key))
-      const scoper = g.resolveScoper<typeof q>()
-      scoper(q, '2026-05-04')
-      assert.deepEqual(calls, ['createdAt = 2026-05-04'])
-    })
-  })
-})

package/src/elements/TableGroup.ts

@@ -1,334 +0,0 @@
-/**
- * Table grouping option. Owned by `Table` (not an `Element` — doesn't
- * sit in the schema tree). Each `TableGroup` defines one column the
- * table can band rows by, plus optional chrome (label, collapsibility,
- * record-derived title and description, date bucketing).
- *
- * Multiple `TableGroup`s can live on a single table via `Table.groups([…])`
- * — the renderer mounts a "Group by" dropdown above the table when more
- * than one is registered. The active selection round-trips through the
- * URL via the reserved `?group=` key.
- */
-
-export type TableGroupTitleHandler<R = unknown> = (
-  record: R,
-) => string | undefined
-
-export type TableGroupDescriptionHandler<R = unknown> = (
-  record: R,
-) => string | undefined
-
-/**
- * Per-record key resolver. The returned string is what `scopeQueryByKey`
- * receives at drill-in time. Default resolution = the raw column value
- * cast to string (or `YYYY-MM-DD` when `.date()` is on). Override when the
- * stable bucket key differs from what the column literally stores —
- * e.g. when grouping by an enum object whose `.value` is the persisted
- * column.
- */
-export type TableGroupKeyHandler<R = unknown> = (
-  record: R,
-) => string | undefined
-
-/**
- * Query scoper applied when the user clicks a group heading to drill into
- * a single group. Receives the raw model query and the resolved group key
- * (the same value `getKeyFromRecordUsing` produced). Should narrow the
- * query to records belonging to that group. Default narrows by exact-match
- * `where(column, '=', key)`; date groups install a whole-day range default.
- */
-export type TableGroupQueryScoper<Q = unknown> = (
-  query: Q,
-  key:   string,
-) => Q
-
-/**
- * Comparator on resolved group keys. Receives the same string values that
- * the dispatcher stamps onto `_groupValue` (so for `date()` groups the keys
- * are `YYYY-MM-DD`, not raw timestamps). Return < 0 to put `a` first, > 0
- * to put `b` first, 0 to keep insertion order. The empty-bucket-last rule
- * is still applied AFTER your comparator — the empty bucket stays at the
- * bottom regardless of what you return for it.
- */
-export type TableGroupKeyComparator = (a: string, b: string) => number
-
-export interface TableGroupMeta {
-  column:        string
-  label:         string
-  collapsible?:  true
-  collapsed?:    true
-  /** Server-side date bucketing is on (column read as a date, grouped
-   * by day). Renderer doesn't need to do anything special — `_groupValue`
-   * already arrives as `YYYY-MM-DD` and `_groupTitle` carries the
-   * formatted display text. */
-  date?:         true
-  /** Heading is clickable — renderer wraps the title text in a real
-   * `<a href>` that sets `?<prefix>groupKey=<value>` to drill into a
-   * single group. Sparse: omitted unless the user opted in (directly
-   * via `.scopable(true)` or implicitly by calling `.scopeQueryByKey()`
-   * / `.getKeyFromRecordUsing()`). */
-  scopable?:     true
-}
-
-export class TableGroup<R = unknown> {
-  private _column:        string
-  private _label?:        string
-  private _collapsible    = false
-  private _collapsed      = false
-  private _titleFn?:       TableGroupTitleHandler<R>
-  private _descriptionFn?: TableGroupDescriptionHandler<R>
-  private _date           = false
-  private _keyComparator?: TableGroupKeyComparator
-  private _scopable       = false
-  private _scopeFn?:       TableGroupQueryScoper<unknown>
-  private _keyFn?:         TableGroupKeyHandler<R>
-
-  private constructor(column: string) {
-    this._column = column
-  }
-
-  static make<R = unknown>(column: string): TableGroup<R> {
-    return new TableGroup<R>(column)
-  }
-
-  /** Display label in the group selector dropdown. Falls back to the
-   * column name when omitted. */
-  label(text: string): this { this._label = text; return this }
-
-  /** Allow individual groups to be folded. Adds a chevron in the heading row. */
-  collapsible(v: boolean = true): this { this._collapsible = v; return this }
-
-  /** Start collapsed by default. Per-group state is persisted client-
-   * side in localStorage; this just seeds the initial state. */
-  collapsed(v: boolean = true): this { this._collapsed = v; return this }
-
-  /** Custom heading text per row. Receives the full record. Falls back
-   * to the raw column value when omitted. Stamped per row server-side
-   * as `_groupTitle`. */
-  getTitleFromRecordUsing(fn: TableGroupTitleHandler<R>): this {
-    this._titleFn = fn
-    return this
-  }
-
-  /** Subtitle below the title. Stamped per row as `_groupDescription`. */
-  getDescriptionFromRecordUsing(fn: TableGroupDescriptionHandler<R>): this {
-    this._descriptionFn = fn
-    return this
-  }
-
-  /** Sugar for grouping by day — the column is read as a date and
-   * bucketed to `YYYY-MM-DD`. Uses `_groupValue` for the bucket key
-   * (so stable-sort still works) and a default title formatter ("May
-   * 4, 2026"). User-supplied title formatter wins. */
-  date(v: boolean = true): this { this._date = v; return this }
-
-  /**
-   * Override the alphabetic ordering of group buckets with a custom
-   * comparator on resolved group keys. Useful for pinning enums in a
-   * meaningful order (e.g. `'draft' → 'published' → 'archived'`).
-   *
-   * The empty-bucket-last rule still runs AFTER this comparator — rows
-   * with no group value always sort to the bottom regardless of what
-   * the comparator returns for the empty key. Pass an array of keys
-   * for the convenient case via the `orderByKeys` helper below.
-   *
-   * Example:
-   * ```ts
-   * TableGroup.make('status').orderUsing(orderByKeys([
-   *   'draft', 'published', 'archived',
-   * ]))
-   * ```
-   */
-  orderUsing(comparator: TableGroupKeyComparator): this {
-    this._keyComparator = comparator
-    return this
-  }
-
-  /**
-   * Make the group heading clickable — clicking it drills the table into
-   * just that group's rows, suppressing the banded layout. Opt-in: most
-   * tables stay in the banded view. Auto-armed whenever the user calls
-   * `.scopeQueryByKey(fn)` or `.getKeyFromRecordUsing(fn)` since neither
-   * is meaningful without the drill-in affordance; pass `.scopable(false)`
-   * explicitly to opt back out after the fact.
-   */
-  scopable(v: boolean = true): this {
-    this._scopable = v
-    return this
-  }
-
-  /**
-   * Narrow the query to a single group's rows when the user drills in.
-   * Receives the raw model query and the resolved group key (same value
-   * `getKeyFromRecordUsing` produces). Default narrows by exact-match
-   * `where(column, '=', key)`; date groups install a whole-day range
-   * default. Auto-arms `.scopable(true)` since a custom scoper without
-   * a clickable heading would never fire.
-   *
-   * ```ts
-   * TableGroup.make('status').scopeQueryByKey((q, key) =>
-   *   q.where('status', '=', key).where('archived', '=', false),
-   * )
-   * ```
-   */
-  scopeQueryByKey<Q = unknown>(fn: TableGroupQueryScoper<Q>): this {
-    this._scopeFn  = fn as TableGroupQueryScoper<unknown>
-    this._scopable = true
-    return this
-  }
-
-  /**
-   * Override the per-record key resolver. The returned string is the
-   * stable bucket key — it round-trips through `?<prefix>groupKey=` on
-   * drill-in and lands as the second arg of `scopeQueryByKey`. Default
-   * = the raw column value cast to string (or `YYYY-MM-DD` when
-   * `.date()` is on). Auto-arms `.scopable(true)`.
-   */
-  getKeyFromRecordUsing(fn: TableGroupKeyHandler<R>): this {
-    this._keyFn    = fn
-    this._scopable = true
-    return this
-  }
-
-  // ─── Getters ──────────────────────────────────────────
-
-  getColumn(): string { return this._column }
-  /** Resolved label — `.label(text)` if set, else the column name. */
-  getLabel(): string { return this._label ?? this._column }
-  isCollapsible(): boolean { return this._collapsible }
-  isCollapsed():   boolean { return this._collapsed }
-  getTitleHandler():       TableGroupTitleHandler<R>       | undefined { return this._titleFn }
-  getDescriptionHandler(): TableGroupDescriptionHandler<R> | undefined { return this._descriptionFn }
-  isDate(): boolean { return this._date }
-  getKeyComparator(): TableGroupKeyComparator | undefined { return this._keyComparator }
-  isScopable(): boolean { return this._scopable }
-  getKeyHandler(): TableGroupKeyHandler<R> | undefined { return this._keyFn }
-
-  /**
-   * Resolve the active scoper. Returns the user-supplied function when
-   * set; otherwise installs a default:
-   *
-   * - **Date groups** (`.date()`): whole-day range over the column —
-   *   `(q, key) => q.where(col, '>=', key + ' 00:00:00').where(col, '<=', key + ' 23:59:59')`.
-   *   Strings are picked over `Date` instances so the default composes
-   *   with ORMs that accept date-string literals; consumers wanting
-   *   sub-day buckets / timezone-aware ranges supply their own scoper.
-   * - **Plain groups**: exact-match — `(q, key) => q.where(col, '=', key)`.
-   *
-   * Note: the default uses `where(col, '>=', …)` 3-arg form. Adapter that
-   * only supports 2-arg `where(col, value)` need to detect the comparison
-   * argument shape — every ORM pilotiq ships against today supports the
-   * 3-arg form via `ModelQuery.where`.
-   */
-  resolveScoper<Q = unknown>(): TableGroupQueryScoper<Q> {
-    if (this._scopeFn) return this._scopeFn as TableGroupQueryScoper<Q>
-    const col = this._column
-    if (this._date) {
-      return ((q: { where: (...args: unknown[]) => unknown }, key: string) => {
-        // Empty key clears the bucket — fall back to a no-op so a stale
-        // groupKey doesn't accidentally filter the table to zero rows.
-        if (key === '') return q
-        return (q
-          .where(col, '>=', `${key} 00:00:00`) as typeof q)
-          .where(col, '<=', `${key} 23:59:59`)
-      }) as unknown as TableGroupQueryScoper<Q>
-    }
-    return ((q: { where: (...args: unknown[]) => unknown }, key: string) =>
-      q.where(col, '=', key)) as unknown as TableGroupQueryScoper<Q>
-  }
-
-  /**
-   * Derive the stable bucket key for a record. User-supplied handler
-   * wins; otherwise falls back to the column's raw value cast to string
-   * (or the `YYYY-MM-DD` bucket when `.date()` is on). Unparseable /
-   * null values resolve to `''` so they cluster under the empty bucket.
-   */
-  resolveKey(record: R): string {
-    if (this._keyFn) {
-      try {
-        const k = this._keyFn(record)
-        return k === undefined ? '' : String(k)
-      } catch {
-        return ''
-      }
-    }
-    const raw = (record as Record<string, unknown>)[this._column]
-    if (this._date) return bucketDateValue(raw)
-    return raw == null || raw === '' ? '' : String(raw)
-  }
-
-  toMeta(): TableGroupMeta {
-    return {
-      column: this._column,
-      label:  this.getLabel(),
-      ...(this._collapsible ? { collapsible: true as const } : {}),
-      ...(this._collapsed   ? { collapsed:   true as const } : {}),
-      ...(this._date        ? { date:        true as const } : {}),
-      ...(this._scopable    ? { scopable:    true as const } : {}),
-    }
-  }
-}
-
-/**
- * Bucket a date-like value to a `YYYY-MM-DD` key. Used by `TableGroup.date()`
- * to compute the stable-sort key for `_groupValue`. Returns `''` for
- * unparseable inputs so they cluster under the empty bucket (which the
- * dispatcher already pushes to the bottom).
- */
-export function bucketDateValue(raw: unknown): string {
-  if (raw == null || raw === '') return ''
-  const d = raw instanceof Date ? raw : new Date(raw as string | number)
-  if (Number.isNaN(d.getTime())) return ''
-  // ISO date in UTC. Tables that need timezone-aware buckets should
-  // override via `.getTitleFromRecordUsing` and roll their own bucket.
-  const y = d.getUTCFullYear()
-  const m = String(d.getUTCMonth() + 1).padStart(2, '0')
-  const day = String(d.getUTCDate()).padStart(2, '0')
-  return `${y}-${m}-${day}`
-}
-
-/**
- * Convenience comparator factory for `TableGroup.orderUsing(...)`. Returns
- * a comparator that sorts the supplied keys in declaration order, with any
- * unknown keys falling through to alphabetic ordering AFTER the listed ones.
- *
- * Use it to pin enum-like values without writing a manual switch:
- *
- * ```ts
- * TableGroup.make('status').orderUsing(orderByKeys(['draft', 'published']))
- * ```
- *
- * The empty bucket is unaffected — `dispatchTable` always sinks empty groups
- * to the bottom regardless of what your comparator returns for them.
- */
-export function orderByKeys(keys: ReadonlyArray<string>): TableGroupKeyComparator {
-  const rank = new Map<string, number>()
-  keys.forEach((k, i) => rank.set(k, i))
-  return (a, b) => {
-    const ra = rank.get(a)
-    const rb = rank.get(b)
-    if (ra !== undefined && rb !== undefined) return ra - rb
-    if (ra !== undefined) return -1
-    if (rb !== undefined) return  1
-    return a < b ? -1 : a > b ? 1 : 0
-  }
-}
-
-/**
- * Default title formatter used when `TableGroup.date()` is on but the
- * user didn't supply `getTitleFromRecordUsing`. Returns "May 4, 2026"-
- * style text, or the raw bucket key if the date is unparseable.
- */
-export function formatDateBucketTitle(raw: unknown): string {
-  if (raw == null || raw === '') return ''
-  const d = raw instanceof Date ? raw : new Date(raw as string | number)
-  if (Number.isNaN(d.getTime())) return String(raw)
-  try {
-    return new Intl.DateTimeFormat('en-US', {
-      year: 'numeric', month: 'long', day: 'numeric',
-      timeZone: 'UTC',
-    }).format(d)
-  } catch {
-    return bucketDateValue(raw)
-  }
-}