@object-ui/plugin-calendar 17.6.0 → 18.0.0

package/README.md

@@ -19,6 +19,11 @@ Calendar view plugins for Object UI - includes both ObjectQL-integrated and stan
   option.
 - **ObjectQL Integration** - Connect to ObjectStack data sources
 - **Standalone Mode** - Use with static data or custom backends
+- **Locale week start** - Every week starts on the first day of the week
+  of the calendar's locale (the `locale` prop, else the display locale):
+  Sunday under `en-US`, Monday under `en-GB` or `zh-CN`. The month grid,
+  its weekday heads, the week view's columns, the header's week range and
+  the date popover all start on that day.
 - **Responsive** - Mobile-friendly calendar layouts
 - **Customizable** - Tailwind CSS styling support
 
@@ -28,8 +33,8 @@ Calendar view plugins for Object UI - includes both ObjectQL-integrated and stan
 
 | Gesture | Effect |
 | --- | --- |
-| Drag the event pill body to another day cell | Shifts both `startDateField` and `endDateField` by the day delta. Grab cell → drop cell defines the delta, so dragging from any day of a multi-day span works as expected. |
-| Drag the right-edge handle of a multi-day pill | Adjusts only `endDateField`; start is preserved. Refuses drops earlier than start. |
+| Drag the event pill body to another day cell | Moves both `startDateField` and `endDateField` by the calendar days from the grabbed cell to the drop cell, each keeping its time of day: a 10:00 event stays at 10:00, even across a DST change. Grab cell → drop cell defines the days, so dragging from any day of a multi-day span works as expected. |
+| Drag the right-edge handle of a multi-day pill | Moves only `endDateField` to the drop day, keeping its time of day; start is preserved. Refuses drops earlier than start. |
 
 ### Week / Day view (time grid)
 
@@ -72,6 +77,32 @@ The new record is optimistically inserted into local state so it
 appears immediately. To override (e.g. open your own create form), pass
 `onDateClick={(day) => …}` — the default behaviour is skipped.
 
+The dialog is offered only where that payload can succeed. If the object
+has a required field outside the set above (a required lookup, a required
+text field other than the title), the click — or a range drag in the
+week/day grid — opens the host's full create form instead: the calendar
+calls `onEdit` with a new record (no `id`) carrying the date values, e.g.
+`onEdit({ due_date: '2026-10-20' })`, and the host pre-fills its create form
+with them. The console does this already. Without an `onEdit`, the gesture
+offers nothing on such an object. Required fields the server fills on insert
+(`readonly`, `system`, `autonumber`) do not count.
+
+## Reporting the visible days
+
+A host that fetches the calendar's records for it, and hands them over as
+`data`, can fetch only the days on screen. `ObjectCalendar` reports them
+through `onVisibleRangeChange={({ start, end }) => …}`: once on mount, and
+again whenever navigation or a view change moves them. `start` is local
+midnight of the first day drawn and `end` local midnight of the day after the
+last, so the range is half-open. In the month view it covers the whole
+six-week grid, including the leading and trailing days of the neighbouring
+months, under the locale's first day of the week; in the week view it is the
+week, and in the day view the day. An unchanged range is not reported again.
+
+`ListView` (`@object-ui/plugin-list`) uses it to fetch a calendar view's
+visible days instead of one batch of the object (objectui#12081). Like the
+other host callbacks, it is forwarded only when the value is a function.
+
 ## Installation
 
 ```bash
@@ -149,30 +180,62 @@ ComponentRegistry.register('my-calendar', ObjectCalendarRenderer);
 ### CalendarView
 
 Display a calendar computed from the node's `data` records. This is the full
-authored surface: `CalendarViewSchema` in `@object-ui/types` declares 13 keys of
-its own, converged on what the registered `calendar-view` renderer actually
-reads (objectui#5667). Two of them — `data` and `className` — refine common
-`BaseSchema` keys; the rest of `BaseSchema` (`id`, `visible`, ...) applies as on
-any node.
+authored surface: `CalendarViewSchema` in `@object-ui/types` declares 15 keys of
+its own. **13 of them are authorable**, converged on what the registered
+`calendar-view` renderer actually reads (objectui#5667), and they are the ones
+listed below. Two of them — `data` and `className` — refine common `BaseSchema`
+keys; the rest of `BaseSchema` (`id`, `visible`, ...) applies as on any node.
+
+**The other two are REFUSALS, not keys you can write.** `body` and `children`
+are declared `never` (objectui#9256): a read-site sweep of every package that
+registers a component measured that no renderer read consumes either content
+channel for a `calendar-view` node — it renders events computed from `data`, not
+child nodes — so authoring one is now refused at `tsc` and at validation instead
+of silently rendering nothing. They are counted above because the interface
+declares them; they are absent from the listing below because the listing is the
+*authorable* surface.
 
 ```typescript
-{
-  type: 'calendar-view',
-  data?: any,                       // records rendered as events (array, or a binding expression)
-  titleField?: string,              // default 'title'
-  startDateField?: string,          // default 'start'
-  endDateField?: string,            // default 'end'
-  allDayField?: string,             // default 'allDay'
-  colorField?: string,              // default 'color'
-  view?: CalendarViewMode,          // 'month' | 'week' | 'day' (default 'month')
-  currentDate?: string | Date,      // ISO string authored; Date from a React host
-  allowCreate?: boolean,            // default false — shows the "New event" button
-  className?: string,               // Tailwind classes for the container
-  onEventClick?: (event: CalendarEvent) => void,   // HOST-ONLY (see below)
-  onViewChange?: (view: CalendarViewMode) => void  // HOST-ONLY (see below)
-}
+import type { CalendarViewSchema, CalendarViewMode, CalendarEvent } from '@object-ui/types';
+
+type CalendarViewNode = {
+  type: 'calendar-view';
+  data?: any;                       // records rendered as events (array, or a binding expression)
+  titleField?: string;              // default 'title'
+  startDateField?: string;          // default 'start'
+  endDateField?: string;            // default 'end'
+  allDayField?: string;             // default 'allDay'
+  colorField?: string;              // default 'color'
+  view?: CalendarViewMode;          // 'month' | 'week' | 'day' (default 'month')
+  currentDate?: string | Date;      // ISO string authored; Date from a React host
+  allowCreate?: boolean;            // default false — shows the "New event" button
+  className?: string;               // Tailwind classes for the container
+  onEventClick?: (event: CalendarEvent) => void;   // HOST-ONLY (see below)
+  onViewChange?: (view: CalendarViewMode) => void; // HOST-ONLY (see below)
+};
+
+// The listing above is held to the shipped type BY THE COMPILER, both
+// directions, rather than by this paragraph: a key whose type here disagrees
+// with what `CalendarViewSchema` declares is a compile error.
+declare const authored: CalendarViewNode;
+declare const shipped: CalendarViewSchema;
+const forwards: CalendarViewSchema = authored;
+const backwards: CalendarViewNode = shipped;
 ```
 
+> **What those two assignments do and do not buy.** They check every key's
+> **type**, in both directions. They do **not** check a key's **spelling**:
+> both assign a declared variable, not a fresh object literal, and TypeScript
+> runs its excess-property check only on a fresh literal. So a key renamed in
+> the listing is an extra optional member on one side and simply absent on the
+> other, and both assignments still compile. A fresh literal IS checked:
+> `CalendarViewSchema` extends `BaseSchema`, which carries no index signature
+> since objectui#8347, so
+> `const node: CalendarViewSchema = { type: 'calendar-view', titleFieldd: 'name' }`
+> is a compile error. Metadata that arrives as data is a question for the zod
+> faces (the strict `StrictAnyComponentSchema` refuses an unknown key), not for
+> TypeScript.
+
 There is deliberately **no authorable `events` key**: the renderer computes its
 events from `data` plus the field-name keys, and drops an authored `events`
 (objectui#4433). Nine formerly declared keys — `events`, `defaultView`,
@@ -233,34 +296,93 @@ const schema = {
 ```
 
 The records above already use the default field names (`title`, `start`, `end`,
-`color`), so no field-name keys are needed; point `titleField` /
-`startDateField` / `endDateField` / `allDayField` / `colorField` at your own
-fields when they differ.
+`color`), so no field-name keys are needed; on a `calendar-view` node, point
+`titleField` / `startDateField` / `endDateField` / `allDayField` / `colorField`
+at your own fields when they differ. They sit flat on this node because
+`CalendarViewSchema` has no `calendar` block: here the flat keys are the only
+spelling. An `object-calendar` takes the same five inside its `calendar` block
+instead (next section).
 
 ### With ObjectQL Integration
 
+Every key below is one `ObjectCalendarSchema` declares. The five field-name keys
+go inside the `calendar` block: `getCalendarConfig` reads that block first and
+returns it whole. A misspelt start-date key inside it is therefore not a partial
+failure either: no record has a date to be placed by, so every one is counted
+as unscheduled under the calendar instead of drawn.
+
+`startDateField` is the only one of the five the calendar needs — `titleField`
+is optional, and an event with no explicit title resolves one through the
+ADR-0079 record display-name chain. A calendar authored with no `calendar`
+block renders the "Calendar configuration required" refusal screen, which says
+so and also names where the key belongs: the view's `calendar` block. That
+matters on an **interface page**, whose `interfaceConfig` has no calendar slot
+of its own — the only lever there is `sourceView`, pointed at a view that
+declares the block (objectui#8170).
+
+The same five keys written flat on the node are **not** a second way to author
+this. That flat spelling is the runtime handoff — `ObjectView` and `ListView`
+emit it on the node they build, and `getCalendarConfig` falls back to it only
+when the node has no `calendar` block — so `ObjectCalendarSchema` declares it
+because the renderer reads it. `@objectstack/spec` refuses it at authoring with
+`unrecognized_keys` and names the `calendar` block in the same diagnostic (one
+key per concept, its Prime Directive #12).
+
 ```typescript
-const schema = {
+import type { ObjectCalendarSchema } from '@object-ui/types';
+
+// What this annotation buys, and what it does not - measured, objectui#7925.
+// It type-checks the VALUES of the declared keys: `defaultView: 'agenda'` and
+// `calendar: { titleField: 42 }` are both compile errors, and
+// `check:doc-snippets` re-runs that check on every commit. Top-level key NAMES
+// are checked too since objectui#8347 removed `BaseSchema`'s `[key: string]: any`,
+// and since objectui#6152 so are the key names inside the `calendar` block: its
+// type is the spec's strict `object-calendar` slot, so a misspelt key there, or
+// a block without `startDateField`, is a compile error as well as a parse error.
+const schema: ObjectCalendarSchema = {
   type: 'object-calendar',
-  object: 'events',
-  titleField: 'name',
-  startField: 'startDate',
-  endField: 'endDate',
-  colorField: 'category.color'
+  objectName: 'events',
+  calendar: {
+    titleField: 'name',
+    startDateField: 'startDate',
+    endDateField: 'endDate',
+    allDayField: 'isAllDay',
+    colorField: 'statusColor'
+  },
+  defaultView: 'month',
+  navigation: { mode: 'modal' }   // what an event click opens - see below
 };
 ```
 
+`navigation` is what an event click opens — the spec's `NavigationConfig` by
+reference, `ViewNavigationConfig` in `@object-ui/types`, the type
+`ObjectGridSchema.navigation` uses: `mode` (`page`, `drawer`, `modal`, `split`,
+`popover`, `new_window` or `none`) with `size`, `openNewTab` and
+`preventNavigation`. With the key absent a click opens the record in a drawer.
+An overlay mode keeps the click from a parent view's `onRowClick` /
+`onEventClick`; any other mode hands it to them. `page` — and a block written
+without `mode`, which takes the spec's `page` default — opens the record page
+through the record navigator the host publishes on `RelatedRecordActionsContext`
+(objectui#11293); the console publishes one on its custom pages, record pages and
+list views. Under a host that publishes none, such as an embedded renderer,
+there is no record page to open and the click opens nothing.
+
 ### Interactive Calendar
 
 The handlers are host-only — a function can only come from a React host
 building the node in code, never from authored JSON:
 
 ```typescript
-const schema = {
+import type { CalendarViewSchema } from '@object-ui/types';
+
+// The annotation is what types the two handler parameters: `event` is
+// `CalendarEvent` and `view` is `CalendarViewMode`, read off the shipped
+// schema. Without it both are implicitly `any`.
+const schema: CalendarViewSchema = {
   type: 'calendar-view',
   data: [],
   onEventClick: (event) => {
-    console.log('Event clicked:', event);
+    console.log('Event clicked:', event.title);
     // Open event details modal
   },
   onViewChange: (view) => {
@@ -276,38 +398,66 @@ Authored JSON reacts to clicks through the node's action channel instead
 
 ## ObjectQL Integration
 
-When using with ObjectStack, the calendar can automatically fetch and display events:
+When using with ObjectStack, the calendar can automatically fetch and display
+events. The adapter is **not** a schema key: `ObjectCalendarRenderer` reads it
+from the renderer context that `SchemaRendererProvider` supplies. The schema
+names the object with `objectName` and its fields inside the same `calendar`
+block as above - there is no `fields` container.
 
 ```typescript
 import { createObjectStackAdapter } from '@object-ui/data-objectstack';
+import type { ObjectCalendarSchema } from '@object-ui/types';
 
 const dataSource = createObjectStackAdapter({
   baseUrl: 'https://api.example.com',
   token: 'your-auth-token'
 });
 
-const schema = {
+// The annotation checks the values of the declared keys, not the key names -
+// see the note on the first `object-calendar` block above.
+const schema: ObjectCalendarSchema = {
   type: 'object-calendar',
-  dataSource,
-  object: 'calendar_events',
-  fields: {
-    title: 'title',
-    start: 'start_time',
-    end: 'end_time',
-    color: 'category_color'
-  }
+  objectName: 'calendar_events',
+  calendar: {
+    titleField: 'title',
+    startDateField: 'start_time',
+    endDateField: 'end_time'
+  },
+  defaultView: 'month'
 };
 ```
 
+Pass the adapter to `SchemaRendererProvider` to wire the fetch up.
+
+**The provider does not change which query keys apply** (objectui#9061, the port
+of objectui#8769). An authored `filter` and `sort` narrow and order the records
+on **every** provider, inline ones included — both `staticData` and
+`data: { provider: 'value', items }` reach the same in-memory adapter the
+`object` provider goes through, so `filter` is evaluated with the same matcher.
+Before objectui#9061 the inline provider skipped that query and drew every
+authored record with an authored `filter` silently dropped. The platform row
+ceiling (2,000 drawn rows, with a footnote naming both numbers — objectui#7210,
+ruling a′) applies to inline records too, and it is applied to the **filtered**
+set, never to the raw one: a large inline array that a `filter` cuts below the
+ceiling draws every matching record and shows no footnote.
+
+⚠️ Two consequences of routing inline records through the adapter. They reach the
+calendar as that adapter's own deep copy rather than as the authored array's
+object identities, so code comparing a record handed to `onEventClick` against
+the authored array with `===` needs `id` equality instead; and the copy is a JSON
+round-trip, so inline records must be JSON-serializable.
+
 ## Customization
 
 Style the calendar with Tailwind classes:
 
 ```typescript
-const schema = {
+import type { CalendarViewSchema } from '@object-ui/types';
+
+const schema: CalendarViewSchema = {
   type: 'calendar-view',
   className: 'border rounded-lg shadow-lg',
-  data: [...]
+  data: [] // your records
 };
 ```
 

package/dist/CalendarView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CalendarView.d.ts","sourceRoot":"","sources":["../src/CalendarView.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA0C9B;;;;;;;;;;GAUG;AACH,iBAAS,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAUtG;AAsBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,IAAI,CAAA;IACX,GAAG,CAAC,EAAE,IAAI,CAAA;IACV,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,GAAG,CAAA;CACX;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC5B,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAA;IAC/B,WAAW,CAAC,EAAE,IAAI,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACjD,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,KAAK,IAAI,CAAA;IACvD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IACjC,UAAU,CAAC,EAAE,MAAM,IAAI,CAAA;IACvB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,IAAI,KAAK,IAAI,CAAA;IAC/E;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,KAAK,IAAI,CAAA;IACpD;2EACuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,iBAAS,YAAY,CAAC,EACpB,MAAW,EACX,IAAc,EACd,WAAiC,EACjC,MAAkB,EAClB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,UAAU,EACV,UAAU,EACV,WAAW,EACX,iBAAiB,EACjB,WAAgB,EAChB,SAAS,GACV,EAAE,iBAAiB,qBA8OnB;AAmhCD,OAAO,EAAE,YAAY,EAAE,CAAA;AACvB,OAAO,EAAE,iBAAiB,IAAI,0BAA0B,EAAE,CAAA"}
+{"version":3,"file":"CalendarView.d.ts","sourceRoot":"","sources":["../src/CalendarView.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA2C9B;;;;;;;;;;GAUG;AACH,iBAAS,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAUtG;AAoCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,IAAI,CAAA;IACX,GAAG,CAAC,EAAE,IAAI,CAAA;IACV,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,GAAG,CAAA;CACX;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC5B,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAA;IAC/B,WAAW,CAAC,EAAE,IAAI,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACjD,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAClC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,KAAK,IAAI,CAAA;IACvD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IACjC,UAAU,CAAC,EAAE,MAAM,IAAI,CAAA;IACvB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,IAAI,KAAK,IAAI,CAAA;IAC/E;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,KAAK,IAAI,CAAA;IACpD;2EACuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,iBAAS,YAAY,CAAC,EACpB,MAAW,EACX,IAAc,EACd,WAAiC,EACjC,MAAkB,EAClB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,UAAU,EACV,UAAU,EACV,WAAW,EACX,iBAAiB,EACjB,WAAgB,EAChB,SAAS,GACV,EAAE,iBAAiB,qBA0SnB;AAsnCD,OAAO,EAAE,YAAY,EAAE,CAAA;AACvB,OAAO,EAAE,iBAAiB,IAAI,0BAA0B,EAAE,CAAA"}

package/dist/ObjectCalendar.d.ts

@@ -1,17 +1,52 @@
 import { default as React } from 'react';
-import { ObjectGridSchema, DataSource } from '@object-ui/types';
-export interface CalendarSchema {
-    type: 'calendar';
-    objectName?: string;
-    dateField?: string;
-    endField?: string;
-    titleField?: string;
-    colorField?: string;
-    filter?: any;
-    sort?: any;
-    /** Initial view mode */
-    defaultView?: 'month' | 'week' | 'day';
-}
+import { ObjectCalendarSchema, DataSource } from '@object-ui/types';
+/**
+ * ⛔ RETIRED (objectui#8651) — a plugin-local `CalendarSchema` used to sit here,
+ * and `ObjectCalendarComponentProps.schema` below was the union of it with
+ * `ObjectGridSchema`. Both arms are gone; the prop is now the published schema
+ * of the element this file is registered as (`index.tsx`, both tags).
+ *
+ * What the union cost, measured with the TypeScript checker on the merge-base
+ * (`getPropertyOfType`, never a grep — objectui#8410). Of the fifteen keys this
+ * renderer reads off the node, FOUR were declared on neither arm and EIGHT on
+ * exactly one, while `ObjectCalendarSchema` already declared ELEVEN of the
+ * fifteen.
+ *
+ * ⚠️ But the cast count is NOT twelve, and an earlier cut of this comment said
+ * it was. `ObjectGridSchema` carried `BaseSchema`'s `[key: string]: any` (until
+ * objectui#8347), so on the UNION the five `CalendarSchema`-only keys resolved through that index
+ * signature and compiled with no cast at all. The checker on the union itself:
+ * DECLARED 8 of 15 (`colorField` `dateField` `defaultView` `endField` `filter`
+ * `objectName` `sort` `titleField`), NOT declared 7 (`allDayField` `calendar`
+ * `data` `endDateField` `navigation` `startDateField` `staticData`), nonsense
+ * control `false`. ⇒ SEVEN reads needed a cast, not twelve.
+ *
+ * ⭐ That reading is worse for the old shape, not better: those five compiled
+ * silently as `any` — admitted through an index signature, never examined —
+ * which is the objectui#6914 defect itself rather than an absence of one. A
+ * cast at least announces the gap. The union's own index signature is `false`,
+ * which is why the other seven had to be cast.
+ *
+ * The two arms failed differently and neither was salvageable:
+ *
+ *   - `ObjectGridSchema` is `type: 'object-grid'`. No producer hands this
+ *     component one: the single call site is this package's `index.tsx`, whose
+ *     two registrations both publish `OBJECT_CALENDAR_INPUTS`.
+ *   - the local interface was absent from this package's barrel, so no importer
+ *     could name it, and it SHADOWED `@object-ui/types`' own published
+ *     `CalendarSchema` — the date-picker primitive reachable at `ui:calendar`
+ *     only (objectui#8499). Its two distinctive members were the alias spellings
+ *     `dateField` / `endField`, which objectui#8355 has since RETIRED at both
+ *     faces — `getCalendarConfig` below reads the declared spellings only, and
+ *     `@object-ui/types` refuses the two by name.
+ *
+ * The shape this leaves is the family's: `ObjectKanban` takes
+ * `ObjectKanbanSchema`, `ObjectGantt` takes `ObjectGanttSchema`, `ObjectMap`
+ * takes `ObjectMapSchema` — and `plugin-map` is registered under two tags with
+ * one published props type, exactly as this package is.
+ *
+ * Pinned in `__tests__/calendarUnionReads-8651.test.tsx`.
+ */
 /**
  * Props of the `ObjectCalendar` React component.
  *
@@ -29,7 +64,7 @@ export interface CalendarSchema {
  * no importer breaks. Tripwire: `__tests__/spec-symbol-4650.test.ts`.
  */
 export interface ObjectCalendarComponentProps {
-    schema: ObjectGridSchema | CalendarSchema;
+    schema: ObjectCalendarSchema;
     dataSource?: DataSource;
     className?: string;
     /** Pre-fetched records passed by a parent (e.g. ObjectView). When provided, skips internal data fetching. */
@@ -37,12 +72,55 @@ export interface ObjectCalendarComponentProps {
     /** Loading state propagated from a parent. Respected only when `data` is also provided. */
     loading?: boolean;
     onEventClick?: (record: any) => void;
-    onRowClick?: (record: any) => void;
+    /**
+     * TWO parameters since objectui#9357, and the second is not decoration: this
+     * prop reaches `useNavigationOverlay` as its `onRowClick`, and `handleClick`
+     * invokes it as `onRowClick(record, event)` — the modifier payload a host
+     * needs to implement Cmd/Ctrl/middle-click for itself. Declaring one
+     * parameter hid the second on the ONE line a host reads. Spelled `any` and
+     * not `HandleClickModifiers` for the reason objectui#9341 measured on
+     * `ObjectKanbanSchema.onCardClick`: that interface lives in
+     * `@object-ui/react`, the published twins in `@object-ui/types` may not name
+     * it, and a host that discovered the payload from the implementation
+     * annotated it `React.MouseEvent` — which a narrower declaration refuses
+     * contravariantly. `BaseSchema`'s own `onClick` / `onChange` / `onSubmit`
+     * already use this spelling for exactly this situation.
+     */
+    onRowClick?: (record: any, event?: any) => void;
     onDateClick?: (date: Date) => void;
+    /**
+     * The host's record form, opened on `record`. This component calls it for
+     * one gesture (objectui#12291): an empty-day click, or a range drag in the
+     * week / day grid, on an object with a required field quick-create cannot
+     * fill (`requiredFieldsQuickCreateCannotFill`). Quick-create could not
+     * succeed there, so the gesture hands the day to the host's full create
+     * form instead of offering the dialog: `record` is then a NEW record — it
+     * carries no `id` — whose keys are the date fields the click sets, written
+     * in their stored form, and the host pre-fills its create form with them.
+     * The console's handler already reads a record without an id as a new one.
+     * With no `onEdit`, that gesture offers nothing on such an object.
+     */
     onEdit?: (record: any) => void;
     onDelete?: (record: any) => void;
     onNavigate?: (date: Date) => void;
     onViewChange?: (view: 'month' | 'week' | 'day') => void;
+    /**
+     * The days the calendar draws, reported to a host that fetches its records
+     * for it (objectui#12081): on mount, and again whenever navigation or a view
+     * change moves them. `start` is local midnight of the first day on screen and
+     * `end` local midnight of the day after the last, so the range is half-open.
+     *
+     * This is the channel `ListView` windows its calendar fetch through: the
+     * calendar alone knows which days it draws (the month grid's leading and
+     * trailing days, the locale's first day of the week, the phone's day view),
+     * so the host is told rather than left to infer them from `onNavigate` and
+     * `onViewChange`, neither of which fires for the state the calendar opens
+     * on.
+     */
+    onVisibleRangeChange?: (range: {
+        start: Date;
+        end: Date;
+    }) => void;
     onEventDrop?: (record: any, newStart: Date, newEnd?: Date) => void;
     locale?: string;
 }

package/dist/ObjectCalendar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObjectCalendar.d.ts","sourceRoot":"","sources":["../src/ObjectCalendar.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAA4D,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAA4B,MAAM,kBAAkB,CAAC;AA8B/F,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,wBAAwB;IACxB,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;CACxC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,gBAAgB,GAAG,cAAc,CAAC;IAC1C,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6GAA6G;IAC7G,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,2FAA2F;IAC3F,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACrC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,KAAK,IAAI,CAAC;IACxD,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAuDD,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,4BAA4B,CAgjBjE,CAAC"}
+{"version":3,"file":"ObjectCalendar.d.ts","sourceRoot":"","sources":["../src/ObjectCalendar.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAA4D,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAkB,MAAM,kBAAkB,CAAC;AA6DzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,oBAAoB,CAAC;IAC7B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6GAA6G;IAC7G,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,2FAA2F;IAC3F,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACrC;;;;;;;;;;;;;OAaG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IAChD,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IACnC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,KAAK,IAAI,CAAC;IACxD;;;;;;;;;;;;OAYG;IACH,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,IAAI,CAAC;QAAC,GAAG,EAAE,IAAI,CAAA;KAAE,KAAK,IAAI,CAAC;IACnE,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA6RD,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,4BAA4B,CA2vCjE,CAAC"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { ObjectCalendar, ObjectCalendarComponentProps } from './ObjectCalendar';
+import { ObjectCalendar, ObjectCalendarComponentProps } from './ObjectCalendar.js';
 export { ObjectCalendar };
 export type { ObjectCalendarComponentProps };
 /**
@@ -9,9 +9,9 @@ export type { ObjectCalendarComponentProps };
  * this component's props. The alias denotes the SAME type and is kept only so
  * existing importers keep compiling.
  */
-export type { ObjectCalendarComponentProps as ObjectCalendarProps } from './ObjectCalendar';
-export { CalendarView } from './CalendarView';
-export type { CalendarViewProps, CalendarViewEvent } from './CalendarView';
+export type { ObjectCalendarComponentProps as ObjectCalendarProps } from './ObjectCalendar.js';
+export { CalendarView } from './CalendarView.js';
+export type { CalendarViewProps, CalendarViewEvent } from './CalendarView.js';
 /**
  * @deprecated Use `CalendarViewEvent`. Renamed in objectui#5044 because
  * `@object-ui/types` owns `CalendarEvent`, where it means the AUTHORING event
@@ -27,7 +27,7 @@ export type { CalendarViewProps, CalendarViewEvent } from './CalendarView';
  * module specifier is judged as its own declaration by
  * `scripts/check-spec-symbol-derivation.mjs`.
  */
-export type { CalendarViewEvent as CalendarEvent } from './CalendarView';
+export type { CalendarViewEvent as CalendarEvent } from './CalendarView.js';
 export declare const ObjectCalendarRenderer: React.FC<{
     schema: any;
     [key: string]: any;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAO1B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAGrE,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EAAE,4BAA4B,EAAE,CAAC;AAE7C;;;;;;GAMG;AACH,YAAY,EAAE,4BAA4B,IAAI,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAG5F,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE3E;;;;;;;;;;;;;;GAcG;AACH,YAAY,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGzE,OAAO,0BAA0B,CAAC;AAyLlC,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAoDhF,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAS1B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAGrE,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EAAE,4BAA4B,EAAE,CAAC;AAE7C;;;;;;GAMG;AACH,YAAY,EAAE,4BAA4B,IAAI,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAG5F,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE3E;;;;;;;;;;;;;;GAcG;AACH,YAAY,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGzE,OAAO,0BAA0B,CAAC;AAkMlC,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CA8D/E,CAAC"}