@object-ui/plugin-calendar 17.5.0 → 17.7.0

package/README.md

@@ -28,8 +28,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)
 
@@ -89,7 +89,7 @@ import '@object-ui/plugin-calendar';
 // Now you can use calendar types in your schemas
 const schema = {
   type: 'calendar-view',
-  events: [
+  data: [
     {
       id: '1',
       title: 'Team Meeting',
@@ -100,49 +100,138 @@ const schema = {
 };
 ```
 
-### Manual Registration
+### What the side-effect import registers
+
+Registration is *only* a side effect of importing the package — the single
+`import '@object-ui/plugin-calendar'` above is the whole of it. There is no
+components map to iterate over: importing the entry point runs the
+`ComponentRegistry.register(...)` calls in `src/index.tsx` and
+`src/calendar-view-renderer.tsx`, which claim these schema types:
+
+| Schema `type` | Namespaced key | Renderer |
+| --- | --- | --- |
+| `object-calendar` | `plugin-calendar:object-calendar` | `ObjectCalendarRenderer` |
+| `calendar` | `view:calendar` | `ObjectCalendarRenderer` |
+| `calendar-view` | `plugin-calendar:calendar-view` | internal wrapper around `CalendarView` (not exported) |
+
+Both spellings work — the namespaced key and the bare `type` fallback.
+
+### Public exports
+
+The package exports components and their types, not a registry map:
+
+```typescript
+import {
+  ObjectCalendar, // ObjectQL-integrated calendar component
+  CalendarView, // standalone calendar component
+  ObjectCalendarRenderer, // the registered renderer for `object-calendar` / `calendar`
+} from '@object-ui/plugin-calendar';
+
+import type {
+  ObjectCalendarComponentProps,
+  CalendarViewProps,
+  CalendarViewEvent,
+} from '@object-ui/plugin-calendar';
+```
+
+To serve the calendar under a registry key of your own, register the exported
+renderer under that key:
 
 ```typescript
-import { calendarComponents } from '@object-ui/plugin-calendar';
 import { ComponentRegistry } from '@object-ui/core';
+import { ObjectCalendarRenderer } from '@object-ui/plugin-calendar';
 
-// Register calendar components
-Object.entries(calendarComponents).forEach(([type, component]) => {
-  ComponentRegistry.register(type, component);
-});
+ComponentRegistry.register('my-calendar', ObjectCalendarRenderer);
 ```
 
 ## Schema API
 
 ### CalendarView
 
-Display a monthly calendar with events:
+Display a calendar computed from the node's `data` records. This is the full
+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',
-  events?: CalendarEvent[],
-  defaultDate?: string,           // ISO date string
-  onEventClick?: (event) => void,
-  onDateClick?: (date) => void,
-  className?: string
-}
+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**:
+> `CalendarViewSchema` extends `BaseSchema`, whose `[key: string]: any` accepts
+> any name, so a key invented or misspelled here is `any` rather than an error
+> (objectui#7927). Key-level validity is the strict `@objectstack/spec` twin's
+> question, not TypeScript's.
+
+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`,
+`defaultDate`, `date`, `views`, `editable`, `onEventCreate`, `onEventUpdate`,
+`onDateChange` — were retired in objectui#5667 because nothing read them on the
+authored-node path and no measured app authors them. `onDateClick` is **not**
+on this schema — it is a `CalendarViewProps` component prop (see
+[Drag-and-Drop](#drag-and-drop) and [Click-to-Create](#click-to-create)).
+
+> **The handlers are host-only.** `onEventClick` and `onViewChange` are
+> forwarded to the component only when the value really is a function, which
+> authored JSON can never produce — supply them from a React host
+> (`<SchemaRenderer ... onEventClick={fn} />`). Authored as JSON strings they
+> are dropped, same as absent.
+
 ### Calendar Event Structure
 
-```typescript
-interface CalendarEvent {
-  id: string;
-  title: string;
-  start: string;                  // ISO datetime string
-  end: string;                    // ISO datetime string
-  description?: string;
-  color?: string;                 // Tailwind color class
-  allDay?: boolean;
-}
+Events are not authored directly — the renderer computes one event per record
+in the node's `data` array, reading the fields the field-name keys point at:
+
+```text
+id:     record.id                 // falls back to record._id, then the array index
+title:  record[titleField]        // default field 'title'
+start:  record[startDateField]    // default field 'start' (ISO datetime string)
+end:    record[endDateField]      // default field 'end' (optional)
+allDay: record[allDayField]       // default field 'allDay'
+color:  record[colorField]        // default field 'color'
+data:   record                    // the whole record rides along
 ```
 
+`@object-ui/types` still exports the `CalendarEvent` interface — it is the
+declared payload type of the host-only `onEventClick` callback.
+
 ## Examples
 
 ### Basic Calendar
@@ -150,7 +239,7 @@ interface CalendarEvent {
 ```typescript
 const schema = {
   type: 'calendar-view',
-  events: [
+  data: [
     {
       id: '1',
       title: 'Product Launch',
@@ -169,91 +258,211 @@ const schema = {
 };
 ```
 
+The records above already use the default field names (`title`, `start`, `end`,
+`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. It does NOT check
+// key NAMES - this interface extends `BaseSchema`, whose `[key: string]: any`
+// admits any spelling, and the `calendar` block is open the same way, so a
+// misspelt key still compiles clean. Read the block as type-checked values,
+// never as a guarded key set.
+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',
-  events: [],
+  data: [],
   onEventClick: (event) => {
-    console.log('Event clicked:', event);
+    console.log('Event clicked:', event.title);
     // Open event details modal
   },
-  onDateClick: (date) => {
-    console.log('Date clicked:', date);
-    // Create new event
+  onViewChange: (view) => {
+    console.log('View changed:', view);
+    // React to the calendar switching between month/week/day
   }
 };
 ```
 
+Authored JSON reacts to clicks through the node's action channel instead
+(`allowCreate: true` dispatches `{ type: 'create' }`; event clicks dispatch
+`{ type: 'event-click' }`).
+
 ## 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',
-  events: [...]
+  data: [] // your records
 };
 ```
 
 ## TypeScript Support
 
-```typescript
-import type { CalendarViewSchema, CalendarEvent } from '@object-ui/plugin-calendar';
+The **authored** (JSON metadata) types live in `@object-ui/types`, not in this
+package — this package imports them too, and does not re-export them:
 
-const event: CalendarEvent = {
-  id: '1',
-  title: 'Meeting',
-  start: '2024-01-15T10:00:00',
-  end: '2024-01-15T11:00:00'
-};
+```typescript
+import type { CalendarViewSchema } from '@object-ui/types';
 
 const schema: CalendarViewSchema = {
   type: 'calendar-view',
-  events: [event]
+  data: [
+    { id: '1', name: 'Meeting', begins: '2024-01-15T10:00:00', ends: '2024-01-15T11:00:00' }
+  ],
+  titleField: 'name',
+  startDateField: 'begins',
+  endDateField: 'ends',
+  view: 'week',
+  allowCreate: true
 };
 ```
 
+> **Two calendar event types — pick by which side you are on.**
+> `@object-ui/types` exports **`CalendarEvent`**, the AUTHORING event
+> (`id: string`, `start` / `end` accept ISO strings with `end` required, plus
+> `description`) — since objectui#5667 it is no longer part of the authored
+> surface (a `calendar-view` node carries `data` records, not events; see
+> [Calendar Event Structure](#calendar-event-structure)), but it remains the
+> declared payload type of the host-only `onEventClick` callback. This package
+> exports **`CalendarViewEvent`** (`CalendarViewProps['events']`), the
+> `CalendarView` **component's runtime** type: `id: string | number` and
+> `start: Date` / `end?: Date`. They are not interchangeable — neither is
+> assignable to the other.
+>
+> Both were spelled `CalendarEvent` until objectui#5044, where IDE auto-import
+> chose between them at random and the wrong pick failed as a remote `TS2322`
+> about `Date`. This package still exports `CalendarEvent` as a **`@deprecated`
+> alias of `CalendarViewEvent`**, so existing importers keep compiling; write
+> `CalendarViewEvent` in new code.
+
 ## Links
 
 - 📚 [Documentation](https://www.objectui.org/docs/plugins/plugin-calendar)

package/dist/CalendarView.d.ts

@@ -21,7 +21,27 @@ declare function resolveEventColor(raw: string | undefined | null): {
     className: string;
     inlineColor?: string;
 };
-export interface CalendarEvent {
+/**
+ * The `CalendarView` component's RUNTIME event: what the React component
+ * receives on its `events` prop, already parsed — `start` / `end` are real
+ * `Date` objects, and `id` may be the numeric key a data source returned.
+ *
+ * Renamed from `CalendarEvent` in objectui#5044, following the objectui#4650
+ * precedent (`ObjectCalendarProps` -> `ObjectCalendarComponentProps`).
+ * `@object-ui/types` owns `CalendarEvent`, where it is the AUTHORING event —
+ * `id: string`, `start` / `end` accepting ISO strings with `end` REQUIRED, plus
+ * a `description` this one does not have. The two are structurally
+ * incompatible in BOTH directions (`id` and `start` each conflict), so picking
+ * the wrong one out of IDE auto-import failed as a remote `TS2322` about
+ * `Date`, never as "you imported from the wrong package" — measured on
+ * `README.md`'s own example, which stayed uncompilable through objectui#5010's
+ * import-path fix because both names were real exports.
+ *
+ * `index.tsx` keeps a `@deprecated` `CalendarEvent` alias for this type, so
+ * existing importers keep compiling; the rename is what stops the collision,
+ * not a removal.
+ */
+export interface CalendarViewEvent {
     id: string | number;
     title: string;
     start: Date;
@@ -31,16 +51,16 @@ export interface CalendarEvent {
     data?: any;
 }
 export interface CalendarViewProps {
-    events?: CalendarEvent[];
+    events?: CalendarViewEvent[];
     view?: "month" | "week" | "day";
     currentDate?: Date;
     locale?: string;
-    onEventClick?: (event: CalendarEvent) => void;
+    onEventClick?: (event: CalendarViewEvent) => void;
     onDateClick?: (date: Date) => void;
     onViewChange?: (view: "month" | "week" | "day") => void;
     onNavigate?: (date: Date) => void;
     onAddClick?: () => void;
-    onEventDrop?: (event: CalendarEvent, newStart: Date, newEnd?: Date) => void;
+    onEventDrop?: (event: CalendarViewEvent, newStart: Date, newEnd?: Date) => void;
     /**
      * Fired in WeekView/DayView when the user drags across an empty area of
      * the time grid to select a time range. The default ObjectCalendar

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,MAAM,WAAW,aAAa;IAC5B,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,aAAa,EAAE,CAAA;IACxB,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,aAAa,KAAK,IAAI,CAAA;IAC7C,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,aAAa,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,IAAI,KAAK,IAAI,CAAA;IAC3E;;;;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;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;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,qBAmQnB;AAqpCD,OAAO,EAAE,YAAY,EAAE,CAAA;AACvB,OAAO,EAAE,iBAAiB,IAAI,0BAA0B,EAAE,CAAA"}

package/dist/ObjectCalendar.d.ts

@@ -1,19 +1,70 @@
 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';
-}
-export interface ObjectCalendarProps {
-    schema: ObjectGridSchema | CalendarSchema;
+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` carries `BaseSchema`'s `[key: string]: any`, 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.
+ *
+ * Renamed off the bare `ObjectCalendarProps` (objectui#4650): from 17.0.0
+ * `@objectstack/spec/ui` owns that name, where it is the AUTHORED props
+ * document of the `object-calendar` element — `z.input<typeof
+ * ObjectCalendarPropsSchema>`, i.e. serialisable authoring keys only. This is
+ * the RENDERER's props: a live `dataSource`, records pre-fetched by a parent,
+ * and the host callbacks below, none of which can exist in authored metadata.
+ * Two layers under one word, resolved the way this repo already resolved it for
+ * `PageHeaderProps` -> `PageHeaderComponentProps` (app-shell) and the
+ * `Record*ComponentProps` family in `@object-ui/types`.
+ *
+ * The barrel keeps `ObjectCalendarProps` as a deprecated alias of this type, so
+ * no importer breaks. Tripwire: `__tests__/spec-symbol-4650.test.ts`.
+ */
+export interface ObjectCalendarComponentProps {
+    schema: ObjectCalendarSchema;
     dataSource?: DataSource;
     className?: string;
     /** Pre-fetched records passed by a parent (e.g. ObjectView). When provided, skips internal data fetching. */
@@ -21,7 +72,21 @@ export interface ObjectCalendarProps {
     /** 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;
     onEdit?: (record: any) => void;
     onDelete?: (record: any) => void;
@@ -30,5 +95,5 @@ export interface ObjectCalendarProps {
     onEventDrop?: (record: any, newStart: Date, newEnd?: Date) => void;
     locale?: string;
 }
-export declare const ObjectCalendar: React.FC<ObjectCalendarProps>;
+export declare const ObjectCalendar: React.FC<ObjectCalendarComponentProps>;
 //# sourceMappingURL=ObjectCalendar.d.ts.map

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;AAyB/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,MAAM,WAAW,mBAAmB;IAClC,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;AAkFD,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAkjBxD,CAAC"}
+{"version":3,"file":"ObjectCalendar.d.ts","sourceRoot":"","sources":["../src/ObjectCalendar.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAoD,MAAM,OAAO,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAkB,MAAM,kBAAkB,CAAC;AA0DzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,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;AAqLD,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,4BAA4B,CA0sCjE,CAAC"}

package/dist/index.d.ts

@@ -1,9 +1,33 @@
 import { default as React } from 'react';
-import { ObjectCalendar, ObjectCalendarProps } from './ObjectCalendar';
+import { ObjectCalendar, ObjectCalendarComponentProps } from './ObjectCalendar.js';
 export { ObjectCalendar };
-export type { ObjectCalendarProps };
-export { CalendarView } from './CalendarView';
-export type { CalendarViewProps, CalendarEvent } from './CalendarView';
+export type { ObjectCalendarComponentProps };
+/**
+ * @deprecated Use `ObjectCalendarComponentProps`. Renamed in objectui#4650
+ * because `@objectstack/spec/ui` owns `ObjectCalendarProps` from 17.0.0, where
+ * it means the AUTHORED props document of the `object-calendar` element — not
+ * 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.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
+ * (`id: string`, `start` / `end` accepting ISO strings with `end` required,
+ * plus `description`) — not this component's runtime event, whose `start` is a
+ * real `Date` and whose `id` may be a number. The two are structurally
+ * incompatible in both directions, so IDE auto-import picking the wrong one
+ * failed as a remote `TS2322`. The alias denotes the SAME type and is kept only
+ * so existing importers keep compiling.
+ *
+ * Spelled with its `from` clause for the same reason the
+ * `ObjectCalendarProps` alias above is (objectui#4650): a re-export with no
+ * module specifier is judged as its own declaration by
+ * `scripts/check-spec-symbol-derivation.mjs`.
+ */
+export type { CalendarViewEvent as CalendarEvent } from './CalendarView.js';
 export declare const ObjectCalendarRenderer: React.FC<{
     schema: any;
     [key: string]: any;