@tasknotes/calendar 0.0.0-stage → 0.1.1

package/dist/esm/core.js

@@ -0,0 +1,85 @@
+import "./chunk-L4WKZ6WT.js";
+import {
+  DAY_MS,
+  ItemStore,
+  MINUTES_PER_DAY,
+  addMonths,
+  dayFromYMD,
+  dayLengthMinutes,
+  dayOf,
+  daysInMonth,
+  daysOfRange,
+  defaultOrder,
+  dependencyConflicts,
+  dependencySatisfied,
+  dependencyType,
+  findFreeSlot,
+  formatDay,
+  formatFloating,
+  formatMinutes,
+  getTimeZone,
+  isValidTimeZone,
+  isoWeekNumber,
+  itemDependencies,
+  layoutLane,
+  layoutRow,
+  layoutTimedDay,
+  packTimed,
+  parseDateInput,
+  parseDay,
+  parseDurationMinutes,
+  parseOrder,
+  plannedMinutes,
+  segmentInWindow,
+  segmentOn,
+  startOfDayInstant,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+  toInstant,
+  wallTime,
+  weekdayOf,
+  ymdOfDay
+} from "./chunk-DVMZ5OXN.js";
+export {
+  DAY_MS,
+  ItemStore,
+  MINUTES_PER_DAY,
+  addMonths,
+  dayFromYMD,
+  dayLengthMinutes,
+  dayOf,
+  daysInMonth,
+  daysOfRange,
+  defaultOrder,
+  dependencyConflicts,
+  dependencySatisfied,
+  dependencyType,
+  findFreeSlot,
+  formatDay,
+  formatFloating,
+  formatMinutes,
+  getTimeZone,
+  isValidTimeZone,
+  isoWeekNumber,
+  itemDependencies,
+  layoutLane,
+  layoutRow,
+  layoutTimedDay,
+  packTimed,
+  parseDateInput,
+  parseDay,
+  parseDurationMinutes,
+  parseOrder,
+  plannedMinutes,
+  segmentInWindow,
+  segmentOn,
+  startOfDayInstant,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+  toInstant,
+  wallTime,
+  weekdayOf,
+  ymdOfDay
+};

package/dist/esm/index.js

@@ -0,0 +1,223 @@
+import "./chunk-L4WKZ6WT.js";
+import {
+  Calendar,
+  DEFAULT_TEXT,
+  Formatter,
+  LAYOUT_KEYS,
+  TIMELINE_UNIT_DAYS,
+  defaultOptions,
+  localeFirstDay
+} from "./chunk-6RRDNLZM.js";
+import {
+  DAY_MS,
+  ItemStore,
+  MINUTES_PER_DAY,
+  addMonths,
+  dayFromYMD,
+  dayLengthMinutes,
+  dayOf,
+  daysInMonth,
+  daysOfRange,
+  defaultOrder,
+  dependencyConflicts,
+  dependencySatisfied,
+  dependencyType,
+  findFreeSlot,
+  formatDay,
+  formatFloating,
+  formatMinutes,
+  getTimeZone,
+  isValidTimeZone,
+  isoWeekNumber,
+  itemDependencies,
+  layoutLane,
+  layoutRow,
+  layoutTimedDay,
+  packTimed,
+  parseDateInput,
+  parseDay,
+  parseDurationMinutes,
+  parseOrder,
+  plannedMinutes,
+  segmentInWindow,
+  segmentOn,
+  startOfDayInstant,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+  toInstant,
+  wallTime,
+  weekdayOf,
+  ymdOfDay
+} from "./chunk-DVMZ5OXN.js";
+
+// src/tasknotes/bases.ts
+var FROM_BASES = {
+  dayGridMonth: "month",
+  timeGridWeek: "week",
+  timeGridCustom: "days",
+  timeGridDay: "day",
+  listWeek: "list",
+  multiMonthYear: "year"
+};
+var TO_BASES = {
+  month: "dayGridMonth",
+  week: "timeGridWeek",
+  days: "timeGridCustom",
+  day: "timeGridDay",
+  list: "listWeek",
+  year: "multiMonthYear"
+};
+function viewFromBases(name, fallback = "month") {
+  return name && FROM_BASES[name] || fallback;
+}
+function viewToBases(view) {
+  return TO_BASES[view] ?? null;
+}
+var BASES_CALENDAR_DEFAULTS = {
+  calendarView: "dayGridMonth",
+  customDayCount: 3,
+  listDayCount: 7,
+  heightMode: "fill",
+  firstDay: 1,
+  timeFormat: "24",
+  weekNumbers: false,
+  showWeekends: true,
+  showAllDaySlot: true,
+  showTodayHighlight: true,
+  todayColumnWidthMultiplier: 1,
+  slotMinTime: "00:00:00",
+  slotMaxTime: "24:00:00",
+  slotDuration: "00:30:00",
+  snapDuration: "00:30:00",
+  scrollTime: "08:00:00",
+  nowIndicator: true,
+  showTimeGrid: true,
+  selectMirror: true,
+  slotEventOverlap: true,
+  eventMinHeight: 15,
+  eventMaxStack: 0,
+  dayMaxEvents: 0,
+  dayMaxEventRows: 0,
+  locale: ""
+};
+var num = (v, fallback) => {
+  const n = typeof v === "string" ? Number(v) : v;
+  return typeof n === "number" && Number.isFinite(n) ? n : fallback;
+};
+var clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function isValidSlotTime(value, maxHours = 23) {
+  const m = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/.exec(value.trim());
+  if (!m) return false;
+  const hh = Number(m[1]);
+  const mm = Number(m[2]);
+  const ss = Number(m[3] ?? 0);
+  if (mm > 59 || ss > 59 || hh > maxHours) return false;
+  if (hh === 48 && (mm || ss)) return false;
+  return true;
+}
+function basesLayoutOptions(s, context = {}) {
+  const d = BASES_CALENDAR_DEFAULTS;
+  const pick = (k) => s[k] ?? d[k];
+  const view = viewFromBases(pick("calendarView"));
+  const showTimeGrid = pick("showTimeGrid") !== false;
+  const time = (k, max = 23) => {
+    const v = s[k];
+    return typeof v === "string" && isValidSlotTime(v, max) ? v : void 0;
+  };
+  let today = num(s.todayColumnWidthMultiplier, 1);
+  today = today < 1 || today > 5 ? 1 : Math.round(today * 2) / 2;
+  const rawMax = s.dayMaxEvents ?? d.dayMaxEvents;
+  let dayMaxEvents = typeof rawMax === "boolean" ? rawMax : num(rawMax, 0) === 0 ? true : clamp(num(rawMax, 0), 1, 20);
+  if (!showTimeGrid && dayMaxEvents === true && view !== "month") dayMaxEvents = false;
+  const rawRows = s.dayMaxEventRows ?? d.dayMaxEventRows;
+  const dayMaxEventRows = typeof rawRows === "boolean" ? 0 : clamp(num(rawRows, 0), 0, 10);
+  const slotDuration = time("slotDuration") ?? d.slotDuration;
+  const locale = (s.locale ?? "").trim();
+  const out = {
+    view,
+    dayCount: clamp(Math.round(num(s.customDayCount, d.customDayCount)), 1, 14),
+    listDayCount: clamp(Math.round(num(s.listDayCount, d.listDayCount)), 1, 365),
+    // The plugin overrode FullCalendar's listWeek with `duration: { days: listDayCount }`,
+    // which aligns to the day (not the week), so saved list views start at the date.
+    listStart: "date",
+    height: context.embedded || s.heightMode === "auto" ? "auto" : "fill",
+    expandRows: !(context.embedded || s.heightMode === "auto"),
+    firstDay: clamp(Math.round(num(s.firstDay, 1)), 0, 6),
+    hour12: (s.timeFormat ?? d.timeFormat) === "12",
+    weekNumbers: pick("weekNumbers") === true,
+    weekends: pick("showWeekends") !== false,
+    allDaySlot: pick("showAllDaySlot") !== false,
+    todayHighlight: pick("showTodayHighlight") !== false,
+    todayWidth: view === "week" || view === "days" ? today : 1,
+    slotMinTime: time("slotMinTime") ?? d.slotMinTime,
+    slotMaxTime: time("slotMaxTime", 48) ?? d.slotMaxTime,
+    slotDuration,
+    snapDuration: time("snapDuration") ?? slotDuration,
+    scrollTime: time("scrollTime", 48) ?? d.scrollTime,
+    nowIndicator: pick("nowIndicator") !== false,
+    timeGrid: showTimeGrid,
+    selectMirror: pick("selectMirror") !== false,
+    slotEventOverlap: pick("slotEventOverlap") !== false,
+    eventMinHeight: clamp(num(s.eventMinHeight, d.eventMinHeight), 15, 100),
+    eventMaxStack: clamp(Math.round(num(s.eventMaxStack, 0)), 0, 10),
+    dayMaxEvents,
+    dayMaxEventRows
+  };
+  if (locale) out.locale = locale;
+  return out;
+}
+export {
+  BASES_CALENDAR_DEFAULTS,
+  Calendar,
+  DAY_MS,
+  DEFAULT_TEXT,
+  Formatter,
+  ItemStore,
+  LAYOUT_KEYS,
+  MINUTES_PER_DAY,
+  TIMELINE_UNIT_DAYS,
+  addMonths,
+  basesLayoutOptions,
+  dayFromYMD,
+  dayLengthMinutes,
+  dayOf,
+  daysInMonth,
+  daysOfRange,
+  defaultOptions,
+  defaultOrder,
+  dependencyConflicts,
+  dependencySatisfied,
+  dependencyType,
+  findFreeSlot,
+  formatDay,
+  formatFloating,
+  formatMinutes,
+  getTimeZone,
+  isValidSlotTime,
+  isValidTimeZone,
+  isoWeekNumber,
+  itemDependencies,
+  layoutLane,
+  layoutRow,
+  layoutTimedDay,
+  localeFirstDay,
+  packTimed,
+  parseDateInput,
+  parseDay,
+  parseDurationMinutes,
+  parseOrder,
+  plannedMinutes,
+  segmentInWindow,
+  segmentOn,
+  startOfDayInstant,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+  toInstant,
+  viewFromBases,
+  viewToBases,
+  wallTime,
+  weekdayOf,
+  ymdOfDay
+};

package/dist/esm/react.js

@@ -0,0 +1,46 @@
+import {
+  Calendar
+} from "./chunk-6RRDNLZM.js";
+import "./chunk-DVMZ5OXN.js";
+
+// src/react/index.tsx
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+function TaskCalendar(props) {
+  const { items, className, style, calendarRef, renderKey, ...options } = props;
+  const host = useRef(null);
+  const cal = useRef(null);
+  const refCb = useRef(calendarRef);
+  refCb.current = calendarRef;
+  useLayoutEffect(() => {
+    const el = host.current;
+    if (!el) return;
+    const instance = new Calendar(el, options, items);
+    cal.current = instance;
+    refCb.current?.(instance);
+    return () => {
+      refCb.current?.(null);
+      instance.destroy();
+      cal.current = null;
+    };
+  }, []);
+  useLayoutEffect(() => {
+    cal.current?.setOptions(options);
+  });
+  useEffect(() => {
+    cal.current?.setItems(items);
+  }, [items]);
+  const firstKey = useRef(true);
+  useEffect(() => {
+    if (firstKey.current) {
+      firstKey.current = false;
+      return;
+    }
+    cal.current?.rerender();
+  }, [renderKey]);
+  return /* @__PURE__ */ jsx("div", { ref: host, className, style });
+}
+export {
+  Calendar,
+  TaskCalendar
+};

package/dist/types/core/date.d.cts

@@ -0,0 +1,30 @@
+/**
+ * Civil (calendar) days are integers: days since 1970-01-01. They carry no time
+ * zone. Instants are epoch milliseconds. A {@link TimeZone} converts between the
+ * two, so all day arithmetic stays exact across DST changes.
+ */
+export type Day = number;
+export declare const DAY_MS = 86400000;
+export declare const MINUTES_PER_DAY = 1440;
+export interface YMD {
+    year: number;
+    month: number;
+    day: number;
+}
+export declare function dayFromYMD(year: number, month: number, day: number): Day;
+export declare function ymdOfDay(day: Day): YMD;
+/** 0 = Sunday … 6 = Saturday. 1970-01-01 was a Thursday. */
+export declare function weekdayOf(day: Day): number;
+export declare function startOfWeek(day: Day, firstDay: number): Day;
+export declare function startOfMonth(day: Day): Day;
+export declare function daysInMonth(year: number, month: number): number;
+/** Adds calendar months, clamping the day of month (Jan 31 + 1 month = Feb 28/29). */
+export declare function addMonths(day: Day, months: number): Day;
+export declare function startOfYear(day: Day): Day;
+export declare function formatDay(day: Day): string;
+export declare function parseDay(value: string): Day | null;
+/** ISO 8601 week number (weeks start Monday; week 1 contains Jan 4). */
+export declare function isoWeekNumber(day: Day): number;
+/** Parses "HH:mm" or "HH:mm:ss" durations (FullCalendar-style, may exceed 24h). */
+export declare function parseDurationMinutes(value: string | number | null | undefined, fallback: number): number;
+export declare function formatMinutes(minutes: number): string;

package/dist/types/core/date.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Civil (calendar) days are integers: days since 1970-01-01. They carry no time
+ * zone. Instants are epoch milliseconds. A {@link TimeZone} converts between the
+ * two, so all day arithmetic stays exact across DST changes.
+ */
+export type Day = number;
+export declare const DAY_MS = 86400000;
+export declare const MINUTES_PER_DAY = 1440;
+export interface YMD {
+    year: number;
+    month: number;
+    day: number;
+}
+export declare function dayFromYMD(year: number, month: number, day: number): Day;
+export declare function ymdOfDay(day: Day): YMD;
+/** 0 = Sunday … 6 = Saturday. 1970-01-01 was a Thursday. */
+export declare function weekdayOf(day: Day): number;
+export declare function startOfWeek(day: Day, firstDay: number): Day;
+export declare function startOfMonth(day: Day): Day;
+export declare function daysInMonth(year: number, month: number): number;
+/** Adds calendar months, clamping the day of month (Jan 31 + 1 month = Feb 28/29). */
+export declare function addMonths(day: Day, months: number): Day;
+export declare function startOfYear(day: Day): Day;
+export declare function formatDay(day: Day): string;
+export declare function parseDay(value: string): Day | null;
+/** ISO 8601 week number (weeks start Monday; week 1 contains Jan 4). */
+export declare function isoWeekNumber(day: Day): number;
+/** Parses "HH:mm" or "HH:mm:ss" durations (FullCalendar-style, may exceed 24h). */
+export declare function parseDurationMinutes(value: string | number | null | undefined, fallback: number): number;
+export declare function formatMinutes(minutes: number): string;

package/dist/types/core/index.d.cts

@@ -0,0 +1,7 @@
+export * from "./date.cjs";
+export * from "./zone.cjs";
+export * from "./types.cjs";
+export * from "./store.cjs";
+export * from "./layout.cjs";
+export * from "./order.cjs";
+export * from "./plan.cjs";

package/dist/types/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./date.js";
+export * from "./zone.js";
+export * from "./types.js";
+export * from "./store.js";
+export * from "./layout.js";
+export * from "./order.js";
+export * from "./plan.js";

package/dist/types/core/layout.d.cts

@@ -0,0 +1,82 @@
+import { type Day } from "./date.cjs";
+import type { NormalizedItem } from "./types.cjs";
+import { type TimeZone } from "./zone.cjs";
+export interface TimedSegment<D = unknown> {
+    item: NormalizedItem<D>;
+    day: Day;
+    /** Wall-clock minutes from local midnight. `endMin` may be 1440. */
+    startMin: number;
+    endMin: number;
+    /** Whether the item starts / ends inside this day. */
+    isStart: boolean;
+    isEnd: boolean;
+}
+export interface TimedPlacement<D = unknown> extends TimedSegment<D> {
+    /** Column within its overlap cluster, and the cluster's column count. */
+    col: number;
+    cols: number;
+    /** Columns the item can stretch across without hitting a neighbour. */
+    span: number;
+    /** Index of the overlap cluster within the day. */
+    cluster: number;
+}
+export interface TimedDayLayout<D = unknown> {
+    day: Day;
+    plan: TimedPlacement<D>[];
+    actual: TimedPlacement<D>[];
+    background: TimedSegment<D>[];
+}
+export declare function segmentOn<D>(n: NormalizedItem<D>, day: Day, zone: TimeZone): TimedSegment<D> | null;
+/**
+ * Clips an item to the wall-clock window [minMinute, maxMinute) of `day`.
+ * The window may run past midnight (maxMinute up to 2880) for grids that show
+ * "48:00"-style ranges. Returned minutes are relative to `day`'s midnight.
+ */
+export declare function segmentInWindow<D>(n: NormalizedItem<D>, day: Day, minMinute: number, maxMinute: number, zone: TimeZone): TimedSegment<D> | null;
+export type ItemOrder<D = unknown> = (a: NormalizedItem<D>, b: NormalizedItem<D>) => number;
+/** FullCalendar's default: start, longer first, all-day first, title. */
+export declare const defaultOrder: ItemOrder;
+/**
+ * Packs overlapping segments into columns. Items in the same overlap cluster
+ * share a column count; each item stretches right until it meets an overlapping
+ * neighbour.
+ */
+export declare function packTimed<D>(segs: TimedSegment<D>[], minMinutes: number, order?: ItemOrder<D>): TimedPlacement<D>[];
+export declare function layoutTimedDay<D>(items: NormalizedItem<D>[], day: Day, zone: TimeZone, minMinutes: number, order?: ItemOrder<D>, window?: [number, number]): TimedDayLayout<D>;
+export interface RowPlacement<D = unknown> {
+    item: NormalizedItem<D>;
+    /** Column range within the row, end exclusive. */
+    startCol: number;
+    endCol: number;
+    level: number;
+    /** False when the item continues before / after the row. */
+    isStart: boolean;
+    isEnd: boolean;
+}
+export interface RowLayout<D = unknown> {
+    placements: RowPlacement<D>[];
+    /** Number of placements per column (for "+N more"). */
+    countByCol: number[];
+    levels: number;
+}
+/**
+ * Lays out items across a row of day columns (a month week, or the all-day
+ * row of a time grid). `days` are the visible days in order; hidden days are
+ * simply absent, and items spanning them are clipped.
+ */
+export declare function layoutRow<D>(items: NormalizedItem<D>[], days: Day[], order?: ItemOrder<D>): RowLayout<D>;
+export interface TimelineBar<D = unknown> {
+    item: NormalizedItem<D>;
+    /** Ms range clipped to the visible window. */
+    startMs: number;
+    endMs: number;
+    clippedStart: boolean;
+    clippedEnd: boolean;
+    /** Sub-row within the lane when bars overlap. */
+    level: number;
+}
+/** Stacks overlapping bars within one lane. */
+export declare function layoutLane<D>(items: NormalizedItem<D>[], windowStart: number, windowEnd: number): {
+    bars: TimelineBar<D>[];
+    levels: number;
+};

package/dist/types/core/layout.d.ts

@@ -0,0 +1,82 @@
+import { type Day } from "./date.js";
+import type { NormalizedItem } from "./types.js";
+import { type TimeZone } from "./zone.js";
+export interface TimedSegment<D = unknown> {
+    item: NormalizedItem<D>;
+    day: Day;
+    /** Wall-clock minutes from local midnight. `endMin` may be 1440. */
+    startMin: number;
+    endMin: number;
+    /** Whether the item starts / ends inside this day. */
+    isStart: boolean;
+    isEnd: boolean;
+}
+export interface TimedPlacement<D = unknown> extends TimedSegment<D> {
+    /** Column within its overlap cluster, and the cluster's column count. */
+    col: number;
+    cols: number;
+    /** Columns the item can stretch across without hitting a neighbour. */
+    span: number;
+    /** Index of the overlap cluster within the day. */
+    cluster: number;
+}
+export interface TimedDayLayout<D = unknown> {
+    day: Day;
+    plan: TimedPlacement<D>[];
+    actual: TimedPlacement<D>[];
+    background: TimedSegment<D>[];
+}
+export declare function segmentOn<D>(n: NormalizedItem<D>, day: Day, zone: TimeZone): TimedSegment<D> | null;
+/**
+ * Clips an item to the wall-clock window [minMinute, maxMinute) of `day`.
+ * The window may run past midnight (maxMinute up to 2880) for grids that show
+ * "48:00"-style ranges. Returned minutes are relative to `day`'s midnight.
+ */
+export declare function segmentInWindow<D>(n: NormalizedItem<D>, day: Day, minMinute: number, maxMinute: number, zone: TimeZone): TimedSegment<D> | null;
+export type ItemOrder<D = unknown> = (a: NormalizedItem<D>, b: NormalizedItem<D>) => number;
+/** FullCalendar's default: start, longer first, all-day first, title. */
+export declare const defaultOrder: ItemOrder;
+/**
+ * Packs overlapping segments into columns. Items in the same overlap cluster
+ * share a column count; each item stretches right until it meets an overlapping
+ * neighbour.
+ */
+export declare function packTimed<D>(segs: TimedSegment<D>[], minMinutes: number, order?: ItemOrder<D>): TimedPlacement<D>[];
+export declare function layoutTimedDay<D>(items: NormalizedItem<D>[], day: Day, zone: TimeZone, minMinutes: number, order?: ItemOrder<D>, window?: [number, number]): TimedDayLayout<D>;
+export interface RowPlacement<D = unknown> {
+    item: NormalizedItem<D>;
+    /** Column range within the row, end exclusive. */
+    startCol: number;
+    endCol: number;
+    level: number;
+    /** False when the item continues before / after the row. */
+    isStart: boolean;
+    isEnd: boolean;
+}
+export interface RowLayout<D = unknown> {
+    placements: RowPlacement<D>[];
+    /** Number of placements per column (for "+N more"). */
+    countByCol: number[];
+    levels: number;
+}
+/**
+ * Lays out items across a row of day columns (a month week, or the all-day
+ * row of a time grid). `days` are the visible days in order; hidden days are
+ * simply absent, and items spanning them are clipped.
+ */
+export declare function layoutRow<D>(items: NormalizedItem<D>[], days: Day[], order?: ItemOrder<D>): RowLayout<D>;
+export interface TimelineBar<D = unknown> {
+    item: NormalizedItem<D>;
+    /** Ms range clipped to the visible window. */
+    startMs: number;
+    endMs: number;
+    clippedStart: boolean;
+    clippedEnd: boolean;
+    /** Sub-row within the lane when bars overlap. */
+    level: number;
+}
+/** Stacks overlapping bars within one lane. */
+export declare function layoutLane<D>(items: NormalizedItem<D>[], windowStart: number, windowEnd: number): {
+    bars: TimelineBar<D>[];
+    levels: number;
+};

package/dist/types/core/order.d.cts

@@ -0,0 +1,7 @@
+import type { ItemOrder } from "./layout.cjs";
+/**
+ * Parses a FullCalendar-style order string such as
+ * `"start,-duration,allDay,title"`. Unknown fields are read from the item, then
+ * from `item.data`. `allDay` sorts all-day items first, as FullCalendar does.
+ */
+export declare function parseOrder<D = unknown>(spec: string | ItemOrder<D> | undefined): ItemOrder<D>;

package/dist/types/core/order.d.ts

@@ -0,0 +1,7 @@
+import type { ItemOrder } from "./layout.js";
+/**
+ * Parses a FullCalendar-style order string such as
+ * `"start,-duration,allDay,title"`. Unknown fields are read from the item, then
+ * from `item.data`. `allDay` sorts all-day items first, as FullCalendar does.
+ */
+export declare function parseOrder<D = unknown>(spec: string | ItemOrder<D> | undefined): ItemOrder<D>;

package/dist/types/core/plan.d.cts

@@ -0,0 +1,42 @@
+import type { Day } from "./date.cjs";
+import type { ItemStore } from "./store.cjs";
+import type { CalendarItem, DependencyType, NormalizedItem } from "./types.cjs";
+/** Minutes of planned (timed, plan-lane, non-background) work on each day. */
+export declare function plannedMinutes<D>(store: ItemStore<D>, days: Day[]): Map<Day, number>;
+/** An item's dependencies with their relationship types resolved ("FS" by default). */
+export declare function itemDependencies(item: Pick<CalendarItem, "dependsOn">): {
+    id: string;
+    type: DependencyType;
+}[];
+/** The relationship created by linking a predecessor edge to a successor edge. */
+export declare function dependencyType(fromEdge: "start" | "finish", toEdge: "start" | "finish"): DependencyType;
+/** Whether a relationship holds: the successor's edge is not before the predecessor's. */
+export declare function dependencySatisfied(type: DependencyType, pred: {
+    startMs: number;
+    endMs: number;
+}, succ: {
+    startMs: number;
+    endMs: number;
+}): boolean;
+/** Items whose relationships are broken, mapped to the ids of the predecessors they break. */
+export declare function dependencyConflicts<D>(store: ItemStore<D>): Map<string, string[]>;
+export interface SlotSearch {
+    /** First and last (exclusive) days to search. */
+    fromDay: Day;
+    toDay: Day;
+    durationMinutes: number;
+    /** Working window as wall minutes, e.g. [540, 1020] for 09:00-17:00. */
+    window: [number, number];
+    /** Don't place anything before this instant (usually now). */
+    notBefore?: number;
+    snapMinutes?: number;
+    /** Items to treat as free time, e.g. the item being placed. */
+    ignore?: (n: NormalizedItem) => boolean;
+    /** Days to skip, e.g. weekends. */
+    skipDay?: (day: Day) => boolean;
+}
+/** Finds the first gap long enough for `durationMinutes` in the working window. */
+export declare function findFreeSlot<D>(store: ItemStore<D>, q: SlotSearch): {
+    startMs: number;
+    endMs: number;
+} | null;