@chelone/core 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Rin
+Copyright (c) 2025 marmelab (the react-admin / ra-core foundation)
+Copyright (c) 2026 Shadmin contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @chelone/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The framework-free core of Chelone, a headless admin engine: resource registry, data, list, record and form controllers, auth and i18n.
+
+```bash
+pnpm add @chelone/core @tanstack/form-core @tanstack/query-core
+```
+
+Docs: https://chelone.dev

package/dist/auth/access-control.d.ts

@@ -0,0 +1,9 @@
+import type { CanAccessParams } from "./types.js";
+/** One grant. `record` predicate (when present) must pass against a provided record. */
+export interface Permission {
+    action: string | string[];
+    resource: string;
+    record?: (record: unknown) => boolean;
+}
+/** Deny-by-default permission matcher (OR across permissions). */
+export declare function canAccessWithPermissions(permissions: Permission[], params: CanAccessParams): boolean;

package/dist/auth/access-control.js

@@ -0,0 +1,27 @@
+function matchesAction(granted, action) {
+  const list = Array.isArray(granted) ? granted : [granted];
+  return list.includes("*") || list.includes(action);
+}
+function matchesResource(granted, resource) {
+  if (granted === "*") return true;
+  if (granted.endsWith(".*")) return resource.startsWith(granted.slice(0, -1));
+  return granted === resource;
+}
+function canAccessWithPermissions(permissions, params) {
+  return permissions.some((permission) => {
+    if (!matchesAction(permission.action, params.action)) return false;
+    if (!matchesResource(permission.resource, params.resource)) return false;
+    if (permission.record) {
+      if (params.record == null) return false;
+      try {
+        return permission.record(params.record);
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+export {
+  canAccessWithPermissions
+};

package/dist/auth/auth-options.d.ts

@@ -0,0 +1,57 @@
+import type { AuthProvider, CanAccessParams, UserIdentity } from "./types.js";
+/** Plain option objects, same convention as the data factories (P2). */
+export declare function identityQueryOptions(authProvider: AuthProvider): {
+    queryKey: readonly ["auth", "getIdentity"];
+    queryFn: () => Promise<UserIdentity>;
+};
+export declare function canAccessQueryOptions(authProvider: AuthProvider, params: CanAccessParams): {
+    queryKey: readonly ["auth", "canAccess", CanAccessParams];
+    queryFn: () => Promise<boolean>;
+};
+export declare function authStateQueryOptions(authProvider: AuthProvider): {
+    queryKey: readonly ["auth", "checkAuth"];
+    queryFn: () => Promise<{
+        authenticated: boolean;
+    }>;
+};
+/**
+ * Fetch the current user permissions via `authProvider.getPermissions`.
+ * No `getPermissions` on the provider = permissions not configured =
+ * resolves `null` (undefined-tolerant; never rejects for that reason). `null`
+ * rather than `undefined` is the sentinel because react-query/vue-query forbid
+ * a queryFn resolving `undefined`. Mirrors {@link canAccessQueryOptions}: keyed
+ * by the passed `params` so distinct param objects cache independently.
+ */
+export declare function permissionsQueryOptions(authProvider: AuthProvider, params?: unknown): {
+    queryKey: readonly ["auth", "getPermissions", unknown];
+    queryFn: () => Promise<unknown>;
+};
+/**
+ * The triage result of {@link checkError}. Vanilla (react/vue-free) so both
+ * adapters share the reject-payload parsing before doing logout/notify/redirect.
+ */
+export interface CheckErrorOutcome {
+    /** The session is invalid (`authProvider.checkError` rejected) — act on it. */
+    logout: boolean;
+    /**
+     * Whether to fully log the user out vs. merely signal "not authorized".
+     * Honors a `logoutUser: false` hint on the reject payload; defaults to
+     * `logout` otherwise. `false` when `logout` is `false`.
+     */
+    logoutUser: boolean;
+    /** Redirect target from the reject payload, falling back to the original error. */
+    redirectTo?: string;
+    /** Notification message hint; `false` asks the adapter to suppress the notice. */
+    message?: string | false;
+}
+/**
+ * Error-triage helper for the data error path. Fail-safe: runs
+ * `authProvider.checkError(error)` and NEVER throws.
+ *
+ * - checkError RESOLVES -> ordinary data error -> `{ logout: false }`.
+ * - checkError REJECTS   -> invalid session -> `{ logout: true, ... }` carrying
+ *   `redirectTo` / `logoutUser` / `message` hints from the reject payload (or,
+ *   for `redirectTo`, the original error). Adapters do the logout + notify +
+ *   redirect; only an auth rejection ever logs the user out.
+ */
+export declare function checkError(authProvider: AuthProvider, error: unknown): Promise<CheckErrorOutcome>;

package/dist/auth/auth-options.js

@@ -0,0 +1,60 @@
+function identityQueryOptions(authProvider) {
+  return {
+    queryKey: ["auth", "getIdentity"],
+    queryFn: async () => {
+      if (!authProvider.getIdentity) {
+        throw new Error(
+          "identityQueryOptions: the authProvider does not implement getIdentity."
+        );
+      }
+      return authProvider.getIdentity();
+    }
+  };
+}
+function canAccessQueryOptions(authProvider, params) {
+  return {
+    queryKey: ["auth", "canAccess", params],
+    // No canAccess on the provider = access control not configured = allow.
+    queryFn: async () => authProvider.canAccess?.(params) ?? true
+  };
+}
+function authStateQueryOptions(authProvider) {
+  return {
+    queryKey: ["auth", "checkAuth"],
+    queryFn: async () => {
+      try {
+        await authProvider.checkAuth();
+        return { authenticated: true };
+      } catch {
+        return { authenticated: false };
+      }
+    }
+  };
+}
+function permissionsQueryOptions(authProvider, params) {
+  return {
+    queryKey: ["auth", "getPermissions", params],
+    queryFn: async () => await authProvider.getPermissions?.(params) ?? null
+  };
+}
+function readProp(source, key) {
+  return source != null && typeof source === "object" && key in source ? source[key] : void 0;
+}
+async function checkError(authProvider, error) {
+  try {
+    await authProvider.checkError(error);
+    return { logout: false, logoutUser: false };
+  } catch (rejection) {
+    const logoutUser = readProp(rejection, "logoutUser") ?? true;
+    const redirectTo = readProp(rejection, "redirectTo") ?? readProp(error, "redirectTo");
+    const message = readProp(rejection, "message");
+    return { logout: true, logoutUser, redirectTo, message };
+  }
+}
+export {
+  authStateQueryOptions,
+  canAccessQueryOptions,
+  checkError,
+  identityQueryOptions,
+  permissionsQueryOptions
+};

package/dist/auth/types.d.ts

@@ -0,0 +1,32 @@
+import type { Identifier } from "../resource/identifier.js";
+export interface UserIdentity {
+    id: Identifier;
+    fullName?: string;
+    avatar?: string;
+    [key: string]: unknown;
+}
+export interface CanAccessParams {
+    action: string;
+    resource: string;
+    record?: unknown;
+}
+/**
+ * The auth contract. All methods return promises; reject = not authenticated /
+ * not permitted. `refreshAuth` is the token-refresh hook point (charter §11);
+ * the P6 shell builds the no-flash SSR gate on `checkAuth`.
+ */
+export interface AuthProvider {
+    login(params: Record<string, unknown>): Promise<void | {
+        redirectTo?: string;
+    }>;
+    logout(params?: unknown): Promise<void | string>;
+    checkAuth(params?: unknown): Promise<void>;
+    checkError(error: unknown): Promise<void>;
+    getIdentity?(): Promise<UserIdentity>;
+    getPermissions?(params?: unknown): Promise<unknown>;
+    canAccess?(params: CanAccessParams): Promise<boolean>;
+    handleCallback?(): Promise<void | {
+        redirectTo?: string;
+    }>;
+    refreshAuth?(): Promise<void>;
+}

package/dist/command-menu/hotkey.d.ts

@@ -0,0 +1,33 @@
+/** The slice of a `KeyboardEvent` the matcher reads, so core needs no DOM types. */
+export interface HotkeyEvent {
+    key: string;
+    /**
+     * The physical key (`KeyboardEvent.code`). Optional. When present it settles
+     * chords whose `key` the modifier rewrote: Option+/ is `"÷"` on macOS and
+     * Shift+1 is `"!"` on a US layout.
+     */
+    code?: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    isComposing?: boolean;
+}
+/** The slice of an `EventTarget` that says whether the user is typing in it. */
+export interface HotkeyTarget {
+    tagName?: string;
+    isContentEditable?: boolean;
+}
+/**
+ * Reads bindings such as `"mod+k"`, `"mod+shift+p"`, `"alt+/"` and `"f1"`.
+ * `mod` is Meta or Ctrl. Modifiers match exactly: a binding without `mod`
+ * does not fire while Ctrl or Meta is down.
+ */
+export declare function matchesHotkey(event: HotkeyEvent, binding: string): boolean;
+export declare function isTypingTarget(target: HotkeyTarget | null | undefined): boolean;
+/**
+ * `matchesHotkey` plus two guards: nothing fires during IME composition, and a
+ * binding with neither `mod` nor `alt` is ignored while `target` is typing, so
+ * `/` never opens the menu from a text field.
+ */
+export declare function shouldHandleHotkey(event: HotkeyEvent, binding: string, target: HotkeyTarget | null | undefined): boolean;

package/dist/command-menu/hotkey.js

@@ -0,0 +1,60 @@
+function parseBinding(binding) {
+  const lower = binding.toLowerCase();
+  const plus = lower === "+" || lower.endsWith("++");
+  const parts = (plus ? lower.slice(0, -1) : lower).split("+");
+  const key = plus ? "+" : parts.pop() ?? "";
+  return {
+    key,
+    mod: parts.includes("mod"),
+    shift: parts.includes("shift"),
+    alt: parts.includes("alt")
+  };
+}
+const punctuationCodes = {
+  "/": "Slash",
+  ".": "Period",
+  ",": "Comma",
+  ";": "Semicolon",
+  "'": "Quote",
+  "[": "BracketLeft",
+  "]": "BracketRight",
+  "\\": "Backslash",
+  "-": "Minus",
+  "=": "Equal",
+  "`": "Backquote"
+};
+function codeFor(key) {
+  if (/^[a-z]$/.test(key)) return `Key${key.toUpperCase()}`;
+  if (/^[0-9]$/.test(key)) return `Digit${key}`;
+  return punctuationCodes[key];
+}
+function keyMatches(event, parsed, eventKey) {
+  if (eventKey === parsed.key) return true;
+  if (!(parsed.alt || parsed.shift) || !event.code) return false;
+  if (/^[a-z0-9]$/i.test(event.key)) return false;
+  return event.code === codeFor(parsed.key);
+}
+function matchesHotkey(event, binding) {
+  const parsed = parseBinding(binding);
+  if (!keyMatches(event, parsed, event.key.toLowerCase())) return false;
+  const modDown = event.metaKey || event.ctrlKey;
+  return modDown === parsed.mod && event.shiftKey === parsed.shift && event.altKey === parsed.alt;
+}
+function isTypingTarget(target) {
+  if (!target) return false;
+  if (target.isContentEditable) return true;
+  const tag = target.tagName?.toLowerCase();
+  return tag === "input" || tag === "textarea" || tag === "select";
+}
+function shouldHandleHotkey(event, binding, target) {
+  if (event.isComposing) return false;
+  if (!matchesHotkey(event, binding)) return false;
+  const { mod, alt } = parseBinding(binding);
+  if (!mod && !alt && isTypingTarget(target)) return false;
+  return true;
+}
+export {
+  isTypingTarget,
+  matchesHotkey,
+  shouldHandleHotkey
+};

package/dist/command-menu/recents.d.ts

@@ -0,0 +1,14 @@
+/** Where the command menu keeps its recents in a `CheloneStore`. */
+export declare const recentsKey = "command-menu.recents";
+/**
+ * A page the user visited. It holds no `path`: the link is rebuilt from the
+ * resource and id, so a basename change cannot strand a saved entry.
+ */
+export interface RecentEntry {
+    type: "resource" | "record";
+    resource: string;
+    id?: string | number;
+    label: string;
+}
+/** Puts `entry` first, drops an earlier copy, and cuts to `limit`. */
+export declare function rememberRecent(recents: readonly RecentEntry[], entry: RecentEntry, limit: number): RecentEntry[];

package/dist/command-menu/recents.js

@@ -0,0 +1,15 @@
+const recentsKey = "command-menu.recents";
+function sameEntry(a, b) {
+  return a.type === b.type && a.resource === b.resource && (a.id === void 0 ? void 0 : String(a.id)) === (b.id === void 0 ? void 0 : String(b.id));
+}
+function rememberRecent(recents, entry, limit) {
+  if (limit < 1) return [];
+  return [entry, ...recents.filter((other) => !sameEntry(other, entry))].slice(
+    0,
+    limit
+  );
+}
+export {
+  recentsKey,
+  rememberRecent
+};

package/dist/command-menu/registry.d.ts

@@ -0,0 +1,34 @@
+import { type MicroStore } from "../store/micro-store.js";
+/**
+ * An extra command in the menu. `label` and `icon` are generic so each adapter
+ * uses its own types (a React node, a Vue component).
+ */
+export interface CommandAction<TLabel = string, TIcon = unknown> {
+    id: string;
+    label: TLabel;
+    icon?: TIcon;
+    /** Heading the command is listed under. Read as `"actions"` when missing. */
+    group?: string;
+    keywords?: string[];
+    shortcut?: string;
+    /** Hides the command when it returns false or throws. */
+    when?: () => boolean;
+    onSelect: () => void;
+}
+export interface CommandRegistry<TLabel = string, TIcon = unknown> {
+    store: MicroStore<{
+        commands: CommandAction<TLabel, TIcon>[];
+    }>;
+    /**
+     * Adds the action, or replaces one with the same id. The returned function
+     * removes it only while it is still the registered one, so a stale cleanup
+     * cannot remove a newer registration.
+     */
+    register(action: CommandAction<TLabel, TIcon>): () => void;
+    unregister(id: string): void;
+}
+export declare const defaultCommandGroup = "actions";
+export declare function createCommandRegistry<TLabel = string, TIcon = unknown>(): CommandRegistry<TLabel, TIcon>;
+export declare function getVisibleCommands<T extends Pick<CommandAction, "when">>(commands: readonly T[]): T[];
+/** Groups in first-seen order. A missing `group` reads as `"actions"`. */
+export declare function groupCommands<T extends Pick<CommandAction, "group">>(commands: readonly T[]): [string, T[]][];

package/dist/command-menu/registry.js

@@ -0,0 +1,53 @@
+import { createMicroStore } from "../store/micro-store.js";
+const defaultCommandGroup = "actions";
+function createCommandRegistry() {
+  const store = createMicroStore({
+    commands: []
+  });
+  const unregister = (id) => {
+    store.setState((prev) => ({
+      commands: prev.commands.filter((command) => command.id !== id)
+    }));
+  };
+  const register = (action) => {
+    store.setState((prev) => {
+      const exists = prev.commands.some((command) => command.id === action.id);
+      return {
+        commands: exists ? prev.commands.map(
+          (command) => command.id === action.id ? action : command
+        ) : [...prev.commands, action]
+      };
+    });
+    return () => {
+      store.setState((prev) => ({
+        commands: prev.commands.filter((command) => command !== action)
+      }));
+    };
+  };
+  return { store, register, unregister };
+}
+function getVisibleCommands(commands) {
+  return commands.filter((command) => {
+    try {
+      return command.when ? command.when() !== false : true;
+    } catch {
+      return false;
+    }
+  });
+}
+function groupCommands(commands) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    const group = command.group ?? defaultCommandGroup;
+    const members = groups.get(group);
+    if (members) members.push(command);
+    else groups.set(group, [command]);
+  }
+  return [...groups];
+}
+export {
+  createCommandRegistry,
+  defaultCommandGroup,
+  getVisibleCommands,
+  groupCommands
+};

package/dist/controller/calendar-dates.d.ts

@@ -0,0 +1,27 @@
+export type CalendarView = "month" | "week" | "agenda";
+/** 0 is Sunday, as in `Date#getDay`. */
+export type CalendarWeekStart = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export interface CalendarRange {
+    /** Local midnight of the first day. */
+    start: Date;
+    /** The last millisecond of the last day. */
+    end: Date;
+}
+/**
+ * A date-only string is local midnight: `new Date("2026-05-01")` reads it as
+ * UTC, which is the previous day west of Greenwich.
+ */
+export declare function parseCalendarDate(value: unknown): Date | undefined;
+export declare function calendarRange(view: CalendarView, anchor: Date, weekStartsOn: CalendarWeekStart): CalendarRange;
+/** One local midnight per day: adding to the day of the month never skips or repeats a day when the clocks change. */
+export declare function calendarDays(range: CalendarRange): Date[];
+export declare function shiftCalendarAnchor(view: CalendarView, anchor: Date, direction: 1 | -1): Date;
+export declare const calendarDayKey: (date: Date) => string;
+export interface CalendarLabels {
+    title(view: CalendarView, anchor: Date, range: CalendarRange): string;
+    weekday(date: Date): string;
+    dayNumber(date: Date): string;
+    hour(hour: number): string;
+    agendaDay(date: Date): string;
+}
+export declare function calendarLabels(locale: string): CalendarLabels;

package/dist/controller/calendar-dates.js

@@ -0,0 +1,123 @@
+const DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const AGENDA_DAYS = 14;
+const atMidnight = (date, dayOffset = 0) => new Date(date.getFullYear(), date.getMonth(), date.getDate() + dayOffset);
+const atEndOfDay = (date, dayOffset = 0) => new Date(
+  date.getFullYear(),
+  date.getMonth(),
+  date.getDate() + dayOffset,
+  23,
+  59,
+  59,
+  999
+);
+const daysFromWeekStart = (date, weekStartsOn) => (date.getDay() - weekStartsOn + 7) % 7;
+function parseCalendarDate(value) {
+  let date;
+  if (value instanceof Date) {
+    date = new Date(value.getTime());
+  } else if (typeof value === "number") {
+    date = new Date(value);
+  } else if (typeof value === "string") {
+    const dateOnly = DATE_ONLY.exec(value);
+    if (dateOnly) {
+      const [year, month, day] = [
+        Number(dateOnly[1]),
+        Number(dateOnly[2]),
+        Number(dateOnly[3])
+      ];
+      date = new Date(2e3, 0, 1);
+      date.setFullYear(year, month - 1, day);
+      if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
+        return void 0;
+      }
+    } else {
+      date = new Date(value);
+    }
+  } else {
+    return void 0;
+  }
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+function calendarRange(view, anchor, weekStartsOn) {
+  if (view === "agenda") {
+    return {
+      start: atMidnight(anchor, -AGENDA_DAYS),
+      end: atEndOfDay(anchor, AGENDA_DAYS)
+    };
+  }
+  const first = view === "month" ? new Date(anchor.getFullYear(), anchor.getMonth(), 1) : anchor;
+  const last = view === "month" ? new Date(anchor.getFullYear(), anchor.getMonth() + 1, 0) : anchor;
+  return {
+    start: atMidnight(first, -daysFromWeekStart(first, weekStartsOn)),
+    end: atEndOfDay(last, 6 - daysFromWeekStart(last, weekStartsOn))
+  };
+}
+function calendarDays(range) {
+  const days = [];
+  const first = atMidnight(range.start);
+  for (let day = first; day.getTime() <= range.end.getTime(); day = atMidnight(first, days.length)) {
+    days.push(day);
+  }
+  return days;
+}
+function shiftCalendarAnchor(view, anchor, direction) {
+  const time = [
+    anchor.getHours(),
+    anchor.getMinutes(),
+    anchor.getSeconds(),
+    anchor.getMilliseconds()
+  ];
+  if (view === "month") {
+    const month = anchor.getMonth() + direction;
+    const lastDay = new Date(anchor.getFullYear(), month + 1, 0).getDate();
+    return new Date(
+      anchor.getFullYear(),
+      month,
+      Math.min(anchor.getDate(), lastDay),
+      ...time
+    );
+  }
+  const step = view === "week" ? 7 : AGENDA_DAYS;
+  return new Date(
+    anchor.getFullYear(),
+    anchor.getMonth(),
+    anchor.getDate() + direction * step,
+    ...time
+  );
+}
+const pad = (value) => String(value).padStart(2, "0");
+const calendarDayKey = (date) => `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+function calendarLabels(locale) {
+  const month = new Intl.DateTimeFormat(locale, {
+    month: "long",
+    year: "numeric"
+  });
+  const span = new Intl.DateTimeFormat(locale, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+  const weekday = new Intl.DateTimeFormat(locale, { weekday: "short" });
+  const dayNumber = new Intl.DateTimeFormat(locale, { day: "numeric" });
+  const hour = new Intl.DateTimeFormat(locale, { hour: "numeric" });
+  const agendaDay = new Intl.DateTimeFormat(locale, {
+    weekday: "long",
+    month: "long",
+    day: "numeric"
+  });
+  return {
+    title: (view, anchor, range) => view === "month" ? month.format(anchor) : span.formatRange(range.start, range.end),
+    weekday: (date) => weekday.format(date),
+    dayNumber: (date) => dayNumber.format(date),
+    hour: (value) => hour.format(new Date(2e3, 0, 1, value)),
+    agendaDay: (date) => agendaDay.format(date)
+  };
+}
+export {
+  calendarDayKey,
+  calendarDays,
+  calendarLabels,
+  calendarRange,
+  parseCalendarDate,
+  shiftCalendarAnchor
+};

package/dist/controller/calendar-events.d.ts

@@ -0,0 +1,54 @@
+import { type CalendarRange } from "./calendar-dates.js";
+export interface CalendarEvent<R> {
+    record: R;
+    start: Date;
+    end?: Date;
+    title: string;
+    color?: string;
+}
+export interface ToCalendarEventsOptions<R> {
+    startSource: string;
+    endSource?: string;
+    titleSource?: string;
+    colorSource?: string;
+    /** Maps the value at `colorSource` to a color. */
+    colorMap?: Record<string, string>;
+    /** The title when `titleSource` is unset or empty: the adapter fills it from the record representation. */
+    getTitle: (record: R) => string;
+}
+/** Records with no usable start are skipped, and an end before the start is dropped. */
+export declare function toCalendarEvents<R>(records: readonly R[], options: ToCalendarEventsOptions<R>): CalendarEvent<R>[];
+/** An event runs from its start day to its end day; an end at midnight leaves its own day out. */
+export declare function calendarEventsOnDay<R>(events: readonly CalendarEvent<R>[], day: Date): CalendarEvent<R>[];
+export declare function calendarEventsInHour<R>(events: readonly CalendarEvent<R>[], day: Date, hour: number): CalendarEvent<R>[];
+export interface CalendarAgendaGroup<R> {
+    day: Date;
+    key: string;
+    events: CalendarEvent<R>[];
+}
+/** Equal starts keep list order. */
+export declare function groupCalendarAgenda<R>(events: readonly CalendarEvent<R>[], range: CalendarRange): CalendarAgendaGroup<R>[];
+/**
+ * Shifts the start and the end by the whole days between the two days, each
+ * keeping its time of day. Adding the duration in milliseconds instead would
+ * move an all-day event's end off midnight when the move crosses a daylight
+ * saving change.
+ */
+export declare function moveCalendarEvent<R>(event: CalendarEvent<R>, fromDay: Date, toDay: Date): {
+    start: Date;
+    end?: Date;
+};
+/**
+ * The list filter that asks for a range. With an `endSource`, an event is kept
+ * when it starts before the range ends and ends after it starts, so one that
+ * began earlier and runs into the range is fetched; a record with an empty end
+ * is then left out. Without one, only the start is bounded, on both sides.
+ */
+export declare function calendarRangeFilter(startSource: string, range: CalendarRange, endSource?: string): Record<string, string>;
+/**
+ * Keys an earlier default filter wrote that the current one no longer does: a
+ * list URL or store can still hold the start's lower bound, which would hide
+ * the event that starts before the range.
+ */
+export declare function staleCalendarRangeKeys(startSource: string, endSource?: string): string[];
+export declare function omitCalendarRangeFilter(filter: Record<string, unknown>, startSource: string, endSource?: string): Record<string, unknown>;