@svgrid/enterprise 2.5.2 → 2.6.0

package/src/scheduler-assignments.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  assignedMinutes,
-  expandAssignments,
-  overallocations,
-  resourceLoad,
-  type SchedulerAssignment,
-} from './scheduler-assignments'
-
-type Ev = { key: string; start: Date; end: Date; resource?: string }
-const D = (h: number) => new Date(2026, 0, 5, h, 0, 0, 0)
-const ev = (key: string, s: number, e: number, resource?: string): Ev => ({ key, start: D(s), end: D(e), resource })
-
-const opts = {
-  keyOf: (e: Ev) => e.key,
-  startOf: (e: Ev) => e.start,
-  endOf: (e: Ev) => e.end,
-  resourceOf: (e: Ev) => e.resource,
-}
-
-describe('expandAssignments', () => {
-  it('renders one event once per assigned resource', () => {
-    const events = [ev('e1', 9, 11)]
-    const assigns: SchedulerAssignment[] = [
-      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
-      { id: 'a2', eventId: 'e1', resourceId: 'r2' },
-    ]
-    const out = expandAssignments(events, assigns, opts)
-    expect(out.map((a) => a.resourceId).sort()).toEqual(['r1', 'r2'])
-    expect(out.every((a) => a.units === 1)).toBe(true)
-  })
-
-  it('dedupes duplicate resource assignments to the max units', () => {
-    const out = expandAssignments([ev('e1', 9, 11)], [
-      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 0.5 },
-      { id: 'a2', eventId: 'e1', resourceId: 'r1', units: 0.8 },
-    ], opts)
-    expect(out).toHaveLength(1)
-    expect(out[0]!.units).toBe(0.8)
-  })
-
-  it('falls back to resourceOf when the event has no assignment', () => {
-    const out = expandAssignments([ev('e1', 9, 11, 'rX')], [], opts)
-    expect(out).toEqual([expect.objectContaining({ resourceId: 'rX', units: 1 })])
-  })
-
-  it('drops an event with neither assignment nor resource', () => {
-    const out = expandAssignments([ev('e1', 9, 11)], [], opts)
-    expect(out).toHaveLength(0)
-  })
-})
-
-describe('resourceLoad', () => {
-  it('sums units of overlapping allocations on the resource', () => {
-    const events = [ev('e1', 9, 11), ev('e2', 10, 12)]
-    const allocs = expandAssignments(events, [
-      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 1 },
-      { id: 'a2', eventId: 'e2', resourceId: 'r1', units: 0.5 },
-    ], opts)
-    expect(resourceLoad(allocs, 'r1', D(10), D(11))).toBe(1.5) // both overlap 10-11
-    expect(resourceLoad(allocs, 'r1', D(9), D(10))).toBe(1) // only e1
-    expect(resourceLoad(allocs, 'r2', D(9), D(12))).toBe(0)
-  })
-})
-
-describe('overallocations', () => {
-  it('flags buckets where load exceeds capacity', () => {
-    const events = [ev('e1', 9, 12), ev('e2', 9, 12)]
-    const allocs = expandAssignments(events, [
-      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
-      { id: 'a2', eventId: 'e2', resourceId: 'r1' },
-    ], opts)
-    const buckets = [{ start: D(9), end: D(10) }, { start: D(10), end: D(11) }]
-    const over = overallocations(allocs, ['r1'], buckets, 1)
-    expect(over).toHaveLength(2) // 2 concurrent > capacity 1, in both buckets
-    expect(over[0]).toMatchObject({ resourceId: 'r1', load: 2, capacity: 1 })
-  })
-
-  it('respects a per-resource capacity function', () => {
-    const events = [ev('e1', 9, 12), ev('e2', 9, 12)]
-    const allocs = expandAssignments(events, [
-      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
-      { id: 'a2', eventId: 'e2', resourceId: 'r1' },
-    ], opts)
-    const over = overallocations(allocs, ['r1'], [{ start: D(9), end: D(10) }], () => 2)
-    expect(over).toHaveLength(0) // capacity 2 absorbs 2 concurrent
-  })
-})
-
-describe('assignedMinutes', () => {
-  it('totals weighted minutes across allocations', () => {
-    const allocs = expandAssignments([ev('e1', 9, 11)], [
-      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 0.5 },
-    ], opts)
-    expect(assignedMinutes(allocs, 'r1')).toBe(60) // 120 min * 0.5
-  })
-})

package/src/scheduler-assignments.ts

@@ -1,134 +0,0 @@
-/**
- * scheduler-assignments - the pure core behind Scheduler Pro *multi-assignment*
- * (one event assigned to several resources) and the *resource utilization
- * histogram*. No Svelte, no DOM. Generic over the event shape via accessor
- * callbacks so it needs no dependency on the grid's ResolvedEvent.
- */
-
-/** A many-to-many event <-> resource link, with an optional allocation (0..1). */
-export type SchedulerAssignment = {
-  id: string
-  eventId: string
-  resourceId: string
-  /** Allocation fraction, default 1 (full). Summed for histogram / overallocation. */
-  units?: number
-}
-
-/** One event placed on one resource (the flattened render unit). */
-export type Allocation<E = unknown> = {
-  event: E
-  key: string
-  resourceId: string
-  units: number
-  start: Date
-  end: Date
-}
-
-export type ExpandOptions<E> = {
-  keyOf: (e: E) => string
-  startOf: (e: E) => Date
-  endOf: (e: E) => Date
-  /** Single-resource fallback when an event has no assignment. */
-  resourceOf?: (e: E) => string | undefined
-}
-
-const MS_MIN = 60_000
-
-/**
- * Flatten events into per-resource allocations. An event with assignments renders
- * once per assigned resource (deduped by eventId+resourceId, keeping the max
- * units); an event with none falls back to its single `resourceOf` (units 1), or
- * is dropped when it has neither. The result drives the resource-column bucketing.
- */
-export function expandAssignments<E>(
-  events: ReadonlyArray<E>,
-  assignments: ReadonlyArray<SchedulerAssignment>,
-  opts: ExpandOptions<E>,
-): Allocation<E>[] {
-  // Group assignments by eventId, collapsing duplicate resources to the max units.
-  const byEvent = new Map<string, Map<string, number>>()
-  for (const a of assignments) {
-    if (!a || !a.eventId || !a.resourceId) continue
-    let m = byEvent.get(a.eventId)
-    if (!m) byEvent.set(a.eventId, (m = new Map()))
-    const units = a.units == null ? 1 : a.units
-    m.set(a.resourceId, Math.max(m.get(a.resourceId) ?? 0, units))
-  }
-
-  const out: Allocation<E>[] = []
-  for (const e of events) {
-    const key = opts.keyOf(e)
-    const start = opts.startOf(e)
-    const end = opts.endOf(e)
-    const m = byEvent.get(key)
-    if (m && m.size) {
-      for (const [resourceId, units] of m) out.push({ event: e, key, resourceId, units, start, end })
-    } else {
-      const resourceId = opts.resourceOf?.(e)
-      if (resourceId != null) out.push({ event: e, key, resourceId, units: 1, start, end })
-    }
-  }
-  return out
-}
-
-/** True when `[aStart,aEnd)` overlaps `[bStart,bEnd)`. */
-function overlaps(aStart: Date, aEnd: Date, bStart: Date, bEnd: Date): boolean {
-  return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime()
-}
-
-/**
- * Summed allocation units on `resourceId` overlapping the bucket
- * `[bucketStart, bucketEnd)` - the height of one histogram bar.
- */
-export function resourceLoad<E>(
-  allocs: ReadonlyArray<Allocation<E>>,
-  resourceId: string,
-  bucketStart: Date,
-  bucketEnd: Date,
-): number {
-  let load = 0
-  for (const a of allocs) {
-    if (a.resourceId !== resourceId) continue
-    if (overlaps(a.start, a.end, bucketStart, bucketEnd)) load += a.units
-  }
-  return load
-}
-
-/** One over-capacity bucket (summed load exceeds the resource capacity). */
-export type Overallocation = { resourceId: string; start: Date; end: Date; load: number; capacity: number }
-
-/**
- * Buckets where a resource's summed load exceeds its capacity. `buckets` are the
- * axis intervals to test; `capacity` is a flat number or a per-resource function
- * (default 1). Used to tint histogram bars / flag conflicts.
- */
-export function overallocations<E>(
-  allocs: ReadonlyArray<Allocation<E>>,
-  resourceIds: ReadonlyArray<string>,
-  buckets: ReadonlyArray<{ start: Date; end: Date }>,
-  capacity: number | ((resourceId: string) => number) = 1,
-): Overallocation[] {
-  const capOf = typeof capacity === 'function' ? capacity : () => capacity
-  const out: Overallocation[] = []
-  for (const resourceId of resourceIds) {
-    const cap = capOf(resourceId)
-    for (const b of buckets) {
-      const load = resourceLoad(allocs, resourceId, b.start, b.end)
-      if (load > cap + 1e-9) out.push({ resourceId, start: b.start, end: b.end, load, capacity: cap })
-    }
-  }
-  return out
-}
-
-/**
- * Total assigned minutes per resource across `allocs` (a simple utilization
- * roll-up for a legend / header, independent of buckets).
- */
-export function assignedMinutes<E>(allocs: ReadonlyArray<Allocation<E>>, resourceId: string): number {
-  let mins = 0
-  for (const a of allocs) {
-    if (a.resourceId !== resourceId) continue
-    mins += ((a.end.getTime() - a.start.getTime()) / MS_MIN) * a.units
-  }
-  return mins
-}

package/src/scheduler-axis.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { buildAxis, resolveZoom, timeToX, xToTime, zoomPresets } from './scheduler-axis'
-
-const day = (d: number, h = 0) => new Date(2026, 0, d, h, 0, 0, 0)
-
-describe('buildAxis - linear (no collapse)', () => {
-  it('maps a full day linearly at pxPerMinute', () => {
-    const axis = buildAxis(day(5), day(6), { pxPerMinute: 1 }) // 1px/min => 1440px
-    expect(axis.totalPx).toBe(1440)
-    expect(timeToX(day(5, 12), axis)).toBe(720) // noon = halfway
-  })
-
-  it('timeToX / xToTime round-trip within a working span', () => {
-    const axis = buildAxis(day(5), day(6), { pxPerMinute: 1 })
-    const t = day(5, 9)
-    expect(xToTime(timeToX(t, axis), axis).getTime()).toBe(t.getTime())
-  })
-})
-
-describe('buildAxis - business hours collapse', () => {
-  it('collapses nights to a fixed gap so working hours dominate', () => {
-    const axis = buildAxis(day(5), day(7), {
-      pxPerMinute: 1,
-      businessHours: { start: 9, end: 17 }, // 8h = 480px working
-      collapseNonWorking: true,
-      collapsedGapPx: 10,
-    })
-    const working = axis.segments.filter((s) => s.kind === 'working')
-    const collapsed = axis.segments.filter((s) => s.kind === 'collapsed')
-    expect(working).toHaveLength(2) // two work days
-    expect(working[0]!.px).toBe(480)
-    // Gaps: before day5 9am, night between, after day6 5pm - each a collapsed 10px.
-    expect(collapsed.every((s) => s.px === 10)).toBe(true)
-    expect(axis.totalPx).toBe(480 * 2 + 10 * collapsed.length)
-  })
-
-  it('omits gaps entirely when collapsedGapPx is 0', () => {
-    const axis = buildAxis(day(5), day(6), {
-      pxPerMinute: 1,
-      businessHours: { start: 9, end: 17 },
-      collapseNonWorking: true,
-      collapsedGapPx: 0,
-    })
-    expect(axis.totalPx).toBe(480) // just the working span
-  })
-})
-
-describe('buildAxis - weekend collapse', () => {
-  it('collapses whole non-working days', () => {
-    // Jan 2026: 3rd = Sat, 4th = Sun. Range Fri Jan 2 -> Mon Jan 5.
-    const axis = buildAxis(day(2), day(5), {
-      pxPerMinute: 1,
-      nonWorkingDays: [0, 6],
-      collapseWeekends: true,
-      collapsedGapPx: 8,
-    })
-    const collapsed = axis.segments.filter((s) => s.kind === 'collapsed')
-    // Sat + Sun are contiguous non-working, so they coalesce to ONE 8px gap.
-    expect(collapsed).toHaveLength(1)
-    expect(collapsed[0]!.px).toBe(8)
-    expect(collapsed[0]!.start.getDate()).toBe(3) // Sat
-    expect(collapsed[0]!.end.getDate()).toBe(5) // through to Mon 00:00
-    // Fri (full day) + Mon-partial working stays full width.
-    const working = axis.segments.filter((s) => s.kind === 'working')
-    expect(working.reduce((sum, s) => sum + s.px, 0)).toBe(1440) // Fri = 1440px working (24h, no business hours)
-  })
-})
-
-describe('buildAxis - piecewise mapping across a collapsed gap', () => {
-  it('maps times on either side of a gap to the right x', () => {
-    const axis = buildAxis(day(5), day(7), {
-      pxPerMinute: 1,
-      businessHours: { start: 9, end: 17 },
-      collapseNonWorking: true,
-      collapsedGapPx: 10,
-    })
-    // End of day 5 work (17:00) sits at leading-gap + 480 working px.
-    const lead = axis.segments[0]!.px // leading collapsed gap (00:00-09:00)
-    expect(timeToX(day(5, 17), axis)).toBe(lead + 480)
-    // Start of day 6 work (09:00) sits one more gap past that.
-    expect(timeToX(day(6, 9), axis)).toBe(lead + 480 + 10)
-  })
-
-  it('round-trips a working-time point through x and back', () => {
-    const axis = buildAxis(day(5), day(7), {
-      pxPerMinute: 1,
-      businessHours: { start: 9, end: 17 },
-      collapseNonWorking: true,
-      collapsedGapPx: 10,
-    })
-    const t = day(6, 13)
-    expect(xToTime(timeToX(t, axis), axis).getTime()).toBe(t.getTime())
-  })
-})
-
-describe('resolveZoom', () => {
-  it('passes a ZoomLevel through and computes pxPerMinute', () => {
-    const level = zoomPresets.find((z) => z.id === 'hour')!
-    const r = resolveZoom(level)
-    expect(r.level.id).toBe('hour')
-    expect(r.pxPerMinute).toBeCloseTo(level.pxPerTick / level.tickMinutes)
-  })
-  it('treats a number as a clamped ladder index', () => {
-    expect(resolveZoom(0).level).toBe(zoomPresets[0])
-    expect(resolveZoom(999).level).toBe(zoomPresets[zoomPresets.length - 1])
-    expect(resolveZoom(-5).level).toBe(zoomPresets[0])
-  })
-})

package/src/scheduler-axis.ts

@@ -1,238 +0,0 @@
-/**
- * scheduler-axis - the pure core behind Scheduler Pro's *non-working-time
- * collapse* and *continuous zoom*. No Svelte, no DOM.
- *
- * Instead of a single linear time<->pixel scale, the timeline axis becomes a
- * PIECEWISE map: working spans keep a full pixel width (`pxPerMinute`), while
- * non-working spans (nights / weekends) collapse to a thin fixed-width gap (or
- * are omitted). {@link buildAxis} produces the ordered segments; {@link timeToX}
- * / {@link xToTime} map across them. The renderer routes all event positioning
- * and drag snapping through these so a collapsed axis stays consistent.
- *
- * Callers supply the range + working definition; this file never reads the clock.
- */
-
-const MS_MIN = 60_000
-const MS_DAY = 86_400_000
-
-export type AxisSegmentKind = 'working' | 'break' | 'collapsed'
-
-/** One contiguous stretch of the axis with a resolved pixel width + offset. */
-export type AxisSegment = {
-  start: Date
-  end: Date
-  /** Left offset in px from the axis origin. */
-  x: number
-  /** Rendered width in px (collapsed gaps get a fixed small width). */
-  px: number
-  kind: AxisSegmentKind
-}
-
-export type Axis = {
-  start: Date
-  end: Date
-  segments: AxisSegment[]
-  totalPx: number
-}
-
-export type BuildAxisOptions = {
-  /** Pixel width of one working minute. Default 0.5 (30px/hour). */
-  pxPerMinute?: number
-  /** Business-hours window in hours, e.g. `{ start: 9, end: 17 }`. Omit = 24h working. */
-  businessHours?: { start: number; end: number }
-  /** Weekday numbers (0 = Sun .. 6 = Sat) treated as non-working days. */
-  nonWorkingDays?: ReadonlyArray<number>
-  /** Collapse nights / breaks (time outside business hours) to a gap. */
-  collapseNonWorking?: boolean
-  /** Collapse whole non-working days (weekends) to a gap. */
-  collapseWeekends?: boolean
-  /** Width (px) of a collapsed gap marker. Default 12; 0 omits it entirely. */
-  collapsedGapPx?: number
-}
-
-/** True when `weekday` is a non-working day. */
-function isNonWorkingDay(weekday: number, days: ReadonlyArray<number> | undefined): boolean {
-  return !!days && days.includes(weekday)
-}
-
-/**
- * The working `[startMs, endMs)` intervals for the local day beginning at
- * `dayStart`, from `businessHours` (or the whole day when omitted). Empty when the
- * day is a non-working day.
- */
-function workingSpansForDay(
-  dayStart: Date,
-  bh: { start: number; end: number } | undefined,
-  nonWorkingDays: ReadonlyArray<number> | undefined,
-): Array<[number, number]> {
-  if (isNonWorkingDay(dayStart.getDay(), nonWorkingDays)) return []
-  const base = dayStart.getTime()
-  if (!bh) return [[base, base + MS_DAY]]
-  const s = base + bh.start * 60 * MS_MIN
-  const e = base + bh.end * 60 * MS_MIN
-  return e > s ? [[s, e]] : []
-}
-
-/**
- * Build the piecewise axis over `[rangeStart, rangeEnd]`. Walks day by day,
- * emitting `working` segments (full width) interleaved with `break` (outside
- * business hours) and whole non-working-day segments. A non-working segment is
- * rendered `collapsed` (fixed gap px) when the matching collapse flag is on, else
- * kept at full width with kind `break`.
- */
-export function buildAxis(rangeStart: Date, rangeEnd: Date, opts: BuildAxisOptions = {}): Axis {
-  const pxPerMinute = opts.pxPerMinute ?? 0.5
-  const gapPx = opts.collapsedGapPx ?? 12
-  const pxOfMs = (ms: number) => (ms / MS_MIN) * pxPerMinute
-
-  // Collect all working spans across the range, clipped to it.
-  const rangeS = rangeStart.getTime()
-  const rangeE = rangeEnd.getTime()
-  const working: Array<[number, number]> = []
-  let day = new Date(rangeStart.getFullYear(), rangeStart.getMonth(), rangeStart.getDate())
-  // Guard: never loop forever; ranges are bounded (days count).
-  let guard = 0
-  while (day.getTime() < rangeE && guard++ < 4000) {
-    for (const [s, e] of workingSpansForDay(day, opts.businessHours, opts.nonWorkingDays)) {
-      const cs = Math.max(s, rangeS)
-      const ce = Math.min(e, rangeE)
-      if (ce > cs) working.push([cs, ce])
-    }
-    day = new Date(day.getTime() + MS_DAY)
-  }
-  working.sort((a, b) => a[0] - b[0])
-
-  // Weave working spans with the non-working gaps between them (and the edges).
-  // Build raw segments (x assigned in a finalize pass so we can coalesce first).
-  type Raw = { start: number; end: number; px: number; kind: AxisSegmentKind }
-  const raw: Raw[] = []
-  let cursor = rangeS
-  const pushSegment = (s: number, e: number, kind: AxisSegmentKind) => {
-    if (e <= s) return
-    if (kind === 'working') {
-      raw.push({ start: s, end: e, px: pxOfMs(e - s), kind })
-      return
-    }
-    // non-working: split into per-day pieces so a whole non-working DAY (weekend)
-    // collapses per `collapseWeekends` while a night / break collapses per
-    // `collapseNonWorking`. Consecutive collapsed pieces are merged below.
-    let a = s
-    while (a < e) {
-      const d = new Date(a)
-      const dayStart = new Date(d.getFullYear(), d.getMonth(), d.getDate())
-      const b = Math.min(e, dayStart.getTime() + MS_DAY)
-      const wholeDayOff = isNonWorkingDay(dayStart.getDay(), opts.nonWorkingDays)
-      const collapse = wholeDayOff ? opts.collapseWeekends : opts.collapseNonWorking
-      if (collapse) raw.push({ start: a, end: b, px: gapPx > 0 ? gapPx : 0, kind: 'collapsed' })
-      else raw.push({ start: a, end: b, px: pxOfMs(b - a), kind: 'break' })
-      a = b
-    }
-  }
-
-  for (const [ws, we] of working) {
-    if (ws > cursor) pushSegment(cursor, ws, 'break') // non-working gap before this span
-    pushSegment(ws, we, 'working')
-    cursor = we
-  }
-  if (cursor < rangeE) pushSegment(cursor, rangeE, 'break') // trailing non-working tail
-
-  // Coalesce consecutive collapsed pieces into one gap marker (a single collapsed
-  // stretch renders as one "gap" of `gapPx`, not one per calendar day), then
-  // assign cumulative x offsets.
-  const segments: AxisSegment[] = []
-  let x = 0
-  for (const r of raw) {
-    const prev = segments[segments.length - 1]
-    if (r.kind === 'collapsed' && prev && prev.kind === 'collapsed') {
-      prev.end = new Date(r.end) // extend the existing gap; px stays fixed
-      continue
-    }
-    segments.push({ start: new Date(r.start), end: new Date(r.end), x, px: r.px, kind: r.kind })
-    x += r.px
-  }
-
-  return { start: rangeStart, end: rangeEnd, segments, totalPx: x }
-}
-
-/** Find the segment containing `t` (by time), or null when outside the axis. */
-function segmentAt(axis: Axis, t: number): AxisSegment | null {
-  for (const seg of axis.segments) {
-    if (t >= seg.start.getTime() && t < seg.end.getTime()) return seg
-  }
-  // Exact end-of-axis maps to the last segment's trailing edge.
-  const last = axis.segments[axis.segments.length - 1]
-  if (last && t === last.end.getTime()) return last
-  return null
-}
-
-/** Map a time to an x offset (px) across the piecewise axis. Clamps to [0,totalPx]. */
-export function timeToX(date: Date, axis: Axis): number {
-  const t = date.getTime()
-  if (t <= axis.start.getTime()) return 0
-  if (t >= axis.end.getTime()) return axis.totalPx
-  const seg = segmentAt(axis, t)
-  if (!seg) return 0
-  const span = seg.end.getTime() - seg.start.getTime()
-  const frac = span > 0 ? (t - seg.start.getTime()) / span : 0
-  return seg.x + frac * seg.px
-}
-
-/** Map an x offset (px) back to a time across the piecewise axis. */
-export function xToTime(x: number, axis: Axis): Date {
-  if (x <= 0) return new Date(axis.start.getTime())
-  if (x >= axis.totalPx) return new Date(axis.end.getTime())
-  for (const seg of axis.segments) {
-    if (x >= seg.x && x < seg.x + seg.px) {
-      const span = seg.end.getTime() - seg.start.getTime()
-      const frac = seg.px > 0 ? (x - seg.x) / seg.px : 0
-      return new Date(seg.start.getTime() + frac * span)
-    }
-  }
-  return new Date(axis.end.getTime())
-}
-
-// --- zoom -------------------------------------------------------------------
-
-export type ZoomMajorUnit = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year'
-
-/** One zoom preset: tick size + pixel density + the coarser grouping unit. */
-export type ZoomLevel = {
-  id: string
-  label: string
-  /** Minutes per minor tick. */
-  tickMinutes: number
-  /** Pixel width of one minor tick. */
-  pxPerTick: number
-  majorUnit: ZoomMajorUnit
-}
-
-/** The built-in zoom ladder, most zoomed-in first (minute detail -> months). */
-export const zoomPresets: ZoomLevel[] = [
-  { id: '5min', label: '5 min', tickMinutes: 5, pxPerTick: 24, majorUnit: 'hour' },
-  { id: '15min', label: '15 min', tickMinutes: 15, pxPerTick: 30, majorUnit: 'hour' },
-  { id: '30min', label: '30 min', tickMinutes: 30, pxPerTick: 40, majorUnit: 'day' },
-  { id: 'hour', label: 'Hourly', tickMinutes: 60, pxPerTick: 50, majorUnit: 'day' },
-  { id: '3hour', label: '3 hours', tickMinutes: 180, pxPerTick: 44, majorUnit: 'day' },
-  { id: 'day', label: 'Daily', tickMinutes: 1440, pxPerTick: 64, majorUnit: 'week' },
-  { id: 'week', label: 'Weekly', tickMinutes: 10_080, pxPerTick: 80, majorUnit: 'month' },
-  { id: 'month', label: 'Monthly', tickMinutes: 43_200, pxPerTick: 72, majorUnit: 'quarter' },
-]
-
-/**
- * Resolve `zoom` to a {@link ZoomLevel}. A `ZoomLevel` passes through; a number is
- * an index into `ladder` (clamped). Returns the pixel density too via
- * `pxPerMinute = pxPerTick / tickMinutes` (use it as `buildAxis`'s `pxPerMinute`).
- */
-export function resolveZoom(
-  zoom: number | ZoomLevel,
-  ladder: ReadonlyArray<ZoomLevel> = zoomPresets,
-): { level: ZoomLevel; pxPerMinute: number } {
-  let level: ZoomLevel
-  if (typeof zoom === 'number') {
-    const i = Math.max(0, Math.min(ladder.length - 1, Math.round(zoom)))
-    level = ladder[i]!
-  } else {
-    level = zoom
-  }
-  return { level, pxPerMinute: level.pxPerTick / level.tickMinutes }
-}

package/src/scheduler-booking.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { afterLead, respectsBuffer, withinDurationBounds, type BusyEvent } from './scheduler-booking'
-
-const D = (h: number, m = 0) => new Date(2026, 0, 5, h, m, 0, 0)
-const ev = (key: string, sh: number, eh: number, data?: unknown): BusyEvent => ({ key, start: D(sh), end: D(eh), data })
-
-describe('respectsBuffer', () => {
-  const others = [ev('a', 9, 10), ev('b', 13, 14)]
-
-  it('passes when the gap before and after is large enough', () => {
-    // book 11:00-12:00: 60 min after a(ends 10), 60 min before b(starts 13) -> ok for 30/30 buffers
-    expect(respectsBuffer(D(11), D(12), others, 30, 30)).toBe(true)
-  })
-  it('rejects a direct overlap', () => {
-    expect(respectsBuffer(D(9, 30), D(10, 30), others, 0, 0)).toBe(false)
-  })
-  it('rejects when the gap before is too small', () => {
-    // book 10:15-11:00: only 15 min after a(ends 10); need 30 -> reject
-    expect(respectsBuffer(D(10, 15), D(11), others, 30, 30)).toBe(false)
-  })
-  it('rejects when the gap after is too small', () => {
-    // book 12:00-12:45: only 15 min before b(starts 13); need 30 -> reject
-    expect(respectsBuffer(D(12), D(12, 45), others, 30, 30)).toBe(false)
-  })
-  it('excludes the moving booking by key', () => {
-    const set = [ev('self', 11, 12), ev('a', 9, 10)]
-    // moving self to 10:00-10:30 would clash with its own old slot unless excluded
-    expect(respectsBuffer(D(10), D(10, 30), set, 0, 0, 'self')).toBe(true)
-  })
-  it('supports a per-neighbour gap (travel time by location)', () => {
-    const jobs = [ev('a', 9, 10, 'north'), ev('b', 13, 14, 'south')]
-    const travel = (n: BusyEvent) => (n.data === 'south' ? 90 : 20) // 90 min to/from south
-    // book 11:00-12:00: 60 min before b(south) but travel needs 90 -> reject
-    expect(respectsBuffer(D(11), D(12), jobs, travel, travel)).toBe(false)
-    // 11:00-11:30 leaves 90 before b -> ok
-    expect(respectsBuffer(D(11), D(11, 30), jobs, travel, travel)).toBe(true)
-  })
-})
-
-describe('withinDurationBounds', () => {
-  it('enforces min and max minutes', () => {
-    expect(withinDurationBounds(D(9), D(9, 30), 30, 90)).toBe(true)
-    expect(withinDurationBounds(D(9), D(9, 15), 30, 90)).toBe(false) // too short
-    expect(withinDurationBounds(D(9), D(11), 30, 90)).toBe(false) // too long
-  })
-  it('treats undefined bounds as unbounded', () => {
-    expect(withinDurationBounds(D(9), D(15), undefined, undefined)).toBe(true)
-  })
-})
-
-describe('afterLead', () => {
-  it('requires the start to be at least leadMin after now', () => {
-    const now = D(10)
-    expect(afterLead(D(12), now, 120)).toBe(true) // exactly 120 min ahead
-    expect(afterLead(D(11), now, 120)).toBe(false) // only 60 min ahead
-  })
-})