# Référence de l’API

> L’API publique de SuperScheduler 0.1.0 : composants, options aux valeurs par défaut vérifiées, callbacks, méthodes du contrôle, modules, Lite et API réservées.

Source: https://superscheduler.org/fr/docs/api-reference/
Reviewed: 2026-10-07

Cette page liste l’API publique qu’implémente SuperScheduler 0.1.0 : les composants React, chaque option avec son type et sa valeur par défaut, regroupées par domaine, les callbacks avec leurs arguments et leur prise en charge de l’annulation ou de l’asynchrone, les méthodes du contrôle, les modules Pro par sous-chemin et l’API Lite. Les membres typés mais non implémentés sont listés à part, sous API réservées : ils émettent un avertissement dans les builds de développement et ne font rien.

Cette référence couvre l’API utilisée dans l’ensemble de ces guides, telle qu’implémentée dans la version 0.1.0. Tout, sauf la section [API Lite](#lite), appartient à SuperScheduler Pro (`super-scheduler`). Les valeurs par défaut sont celles que le contrôle utilise quand vous omettez une option ; « aucune » signifie que l’option n’a pas de valeur tant que vous n’en définissez pas. Les guides expliquent comment combiner ces éléments ; les [exemples](https://superscheduler.org/fr/examples/) les montrent dans des applications qui fonctionnent.

Quelques conventions valent partout :

- `DateInput` est `SuperScheduler.Date | string`. Les chaînes sont des valeurs ISO 8601 civiles avec secondes (`'2026-10-01T14:00:00'`) ou des dates (`'2026-10-01'`). Les fins d’événements sont exclusives.
- Les id de ressources, d’événements et de liens sont de type `string | number` et sont comparés strictement : `1` et `'1'` sont différents.
- Les options sont à la fois des props de `SuperSchedulerComponent`, des clés de `control.update(options)` et des propriétés vivantes du contrôle.
- Les handlers s’exécutent avec `this` lié au contrôle. Leurs valeurs de retour sont ignorées, et un handler `async` n’est pas attendu : utilisez le protocole `async` et `loaded()` là où il existe.

## Points d’entrée
| Import | Édition | Exports | Guide |
|---|---|---|---|
| `super-scheduler` | Pro | `SuperSchedulerComponent`, `useSchedulerControl`, l’espace de noms `SuperScheduler`, `SchedulerDate`, `SchedulerEvent`, `version` et les types publics | [Intégration React](https://superscheduler.org/fr/docs/react-integration/) |
| `super-scheduler/styles.css` | Pro | La feuille de style (un seul `@layer super-scheduler`) | [Thèmes](https://superscheduler.org/fr/docs/theming/) |
| `super-scheduler/react-render` | Pro | `SuperSchedulerComponent` avec les props de rendu React | [Slots de rendu React](https://superscheduler.org/fr/docs/react-render-slots/) |
| `super-scheduler/history` | Pro | `createHistory` | [Annuler et rétablir](https://superscheduler.org/fr/docs/undo-redo/) |
| `super-scheduler/minimap` | Pro | `createMinimap`, `SchedulerMinimap`, `eventDensity` | [Minimap](https://superscheduler.org/fr/docs/minimap-metrics/) |
| `super-scheduler/panes` | Pro | `SchedulerPanes`, `linkPanes` | [Volets et vues enregistrées](https://superscheduler.org/fr/docs/panes-saved-views/) |
| `super-scheduler/zoom-ui` | Pro | `createZoomHud`, `createZoomSlider`, `createLodBadge` | [Échelles de temps et zoom](https://superscheduler.org/fr/docs/time-scales-zoom/) |
| `super-scheduler/views` | Pro | `getViewState`, `applyViewState` | [Volets et vues enregistrées](https://superscheduler.org/fr/docs/panes-saved-views/) |
| `super-scheduler/ranges` | Pro | `createRangeLoader` | [Chargement par plages](https://superscheduler.org/fr/docs/range-loading/) |
| `super-scheduler/hooks` | Pro | `useScheduler`, `useSchedulerState`, `subscribeScheduler`, `getSchedulerSnapshot` | [État contrôlé](https://superscheduler.org/fr/docs/controlled-state/) |
| `super-scheduler/tailwind` | Pro | Preset Tailwind CSS v3 (`export =`) | [Thèmes](https://superscheduler.org/fr/docs/theming/) |
| `super-scheduler/datasets` | Pro | `generateDataset`, `generateScenario`, `toSuperSchedulerData`, `SCENARIOS`, `Prng` | [Performances](https://superscheduler.org/fr/docs/performance-virtualization/#measuring) |
| `super-scheduler/core` | Pro | Dates, durées, frises, index et utilitaires de mise en page sans DOM | |
| `super-scheduler-lite` | Lite | `SuperSchedulerComponent`, l’espace de noms `SuperScheduler`, `SchedulerDate`, `version` | [Démarrage rapide avec Lite](https://superscheduler.org/fr/docs/quick-start-lite/) |
| `super-scheduler-lite/styles.css` | Lite | La feuille de style Lite | [Démarrage rapide avec Lite](https://superscheduler.org/fr/docs/quick-start-lite/) |

Chaque point d’entrée est livré en ESM et en CommonJS, avec ses déclarations de types. React 18.2 ou ultérieur, ou 19, est une dépendance peer (React DOM aussi pour Pro) ; il n’y a aucune dépendance à l’exécution. Tous les modules peuvent être importés sur un serveur sans DOM.

## Composants
### SuperSchedulerComponent
`SuperSchedulerComponent` héberge un contrôle. Ses props (`SchedulerProps`) sont toutes les options et tous les handlers ci-dessous, plus `controlRef`. Il rend un `<div>` sans style, n’a pas de props `className`, `style` ni `id`, et ne transmet à `control.update()` que les props dont l’identité a changé depuis le dernier rendu ; une prop qui disparaît revient à sa valeur par défaut.

| Membre | Type | Remarques |
|---|---|---|
| `ref.current.control` | `SuperScheduler.Scheduler` | Assigné au montage ; après le démontage, c’est le contrôle libéré |
| `controlRef` | `MutableRefObject<Scheduler \| null>` ou `(control) => void` | Les objets ref sont renseignés au montage et vidés au démontage ; les fonctions ne sont appelées avec le contrôle qu’au montage |
| `useSchedulerControl()` | `{ controlRef, control }` | `control` est un état React : `null` jusqu’au montage, puis le contrôle, `null` après le démontage |

Le composant de `super-scheduler/react-render` accepte les mêmes props, plus `renderEvent`, `renderCell`, `renderRowHeader`, `renderTimeHeader`, `renderArea`, `renderCorner`, `eventHover`, les handlers `onBefore*DomAdd` et `onBefore*DomRemove`, et `renderOptions` (voir [react-render](#react-render)).

```tsx
// src/control-access.tsx
import { useEffect, useRef } from 'react'
import { SuperScheduler, SuperSchedulerComponent, useSchedulerControl } from 'super-scheduler'
import { useScheduler } from 'super-scheduler/hooks'

const CONFIG = {
  startDate: '2026-10-01',
  days: 31,
  scale: 'Day',
} satisfies SuperScheduler.SchedulerConfig

// 1. A class ref: `ref.current.control` exists after mount.
export function WithRef() {
  const ref = useRef<SuperSchedulerComponent>(null)
  useEffect(() => ref.current?.control.scrollTo('2026-10-15', true, 'middle'), [])
  return <SuperSchedulerComponent ref={ref} {...CONFIG} />
}

// 2. The control as React state: null until mount, then the live control.
export function WithHook() {
  const { controlRef, control } = useSchedulerControl()
  useEffect(() => control?.scrollTo(SuperScheduler.Date.today()), [control])
  return <SuperSchedulerComponent controlRef={controlRef} {...CONFIG} />
}

// 3. Control plus tracked state topics, published after changes settle.
export function WithState() {
  const { controlRef, state } = useScheduler({ track: ['zoom', 'viewport'] })
  return (
    <>
      <p>
        {state.viewport === undefined
          ? ''
          : `${state.viewport.start.toString('d MMM')} to ${state.viewport.end.toString('d MMM')}`}
      </p>
      <SuperSchedulerComponent controlRef={controlRef} {...CONFIG} />
    </>
  )
}

// 4. Imperative, without React: init() before use, dispose() on teardown.
export function mount(host: HTMLElement): () => void {
  const control = new SuperScheduler.Scheduler(host, CONFIG)
  control.init()
  return () => control.dispose()
}
```
### Types
| Type | Signification |
|---|---|
| `SchedulerProps` | Props de `SuperSchedulerComponent` |
| `SchedulerConfig` | Options acceptées par `new SuperScheduler.Scheduler()` et `control.update()` |
| `SchedulerOptions`, `SchedulerEventHandlers` | Les deux moitiés de la configuration : options et handlers |
| `SchedulerApi` | L’interface du contrôle (même forme que `SuperScheduler.Scheduler`) |
| `Scheduler...Args` | Une interface par handler, par exemple `SchedulerEventMoveArgs`, `SchedulerEventsChangeArgs` |
| `SuperScheduler.EventData<T>`, `SuperScheduler.ResourceData<T>` | Formes des données, génériques sur vos champs supplémentaires |
| `SchedulerCustomProps` | Extensible avec `declare module 'super-scheduler'` pour vos propres props |

## Formes des données
### Événements
`SuperScheduler.EventData<T>` n’a pas de signature d’index : déclarez les champs supplémentaires via le paramètre de type, par exemple `EventData<{ guest: string }>`.

| Champs | Type | Signification |
|---|---|---|
| `id`, `start`, `end`, `text` | `EventId`, `DateInput`, `DateInput`, `string` | Obligatoires. `end` est exclusif, sauf avec `eventEndSpec: 'Date'` |
| `resource` | `ResourceId` | Ligne de l’événement |
| `backColor`, `fontColor`, `borderColor`, `barColor`, `barBackColor` | `string` | Couleurs |
| `cssClass`, `padding`, `borderRadius`, `height` | `string`, `string \| number`, `string \| number`, `number` | Présentation |
| `html`, `htmlLeft`, `htmlRight` | `string` | HTML de confiance, jamais échappé ; échappez le texte des utilisateurs avec `SuperScheduler.Util.escapeHtml` |
| `toolTip`, `bubbleHtml`, `areas`, `contextMenu` | `string`, `string`, `AreaData[]`, `Menu` | Infobulle, contenu de la bulle, zones cliquables, menu |
| `moveDisabled`, `resizeDisabled`, `moveHDisabled`, `moveVDisabled` | `boolean` | Verrous : tout déplacement, redimensionnement, déplacements horizontaux, changements de ligne |
| `clickDisabled`, `doubleClickDisabled`, `rightClickDisabled`, `deleteDisabled`, `moveSkipNonBusinessDisabled` | `boolean` | Désactivations par événement |
| `hidden`, `barHidden` | `boolean` | Masquent l’événement ou sa barre de durée |
| `complete` | `number` | Pourcentage pour `durationBarMode: 'PercentComplete'` |
| `line`, `minLine`, `sort` | `'dedicated' \| number`, `number`, `string[]` | Contrôle de l’empilement |
| `tags` | `unknown` | Données libres |

### Ressources
`SuperScheduler.ResourceData<T>` accepte des champs supplémentaires.

| Champs | Type | Signification |
|---|---|---|
| `id`, `name` | `ResourceId`, `string` | Id et libellé de la ligne |
| `children`, `expanded` | `ResourceData[]`, `boolean` | Lignes d’arborescence (nécessitent `treeEnabled`) ; les parents sont repliés sauf avec `expanded: true` |
| `frozen` | `'top' \| 'bottom'` | Ligne figée au-dessus ou en dessous des lignes qui défilent |
| `split` | `ResourceData[]` | Plusieurs lignes sous une même cellule d’en-tête |
| `columns` | `ResourceColumnData[]` | Cellules pour `rowHeaderColumns`, par index |
| `cellsDisabled` | `boolean` | Toutes les cellules de la ligne sont désactivées : hachurées, sans dépôt, sans sélection |
| `preventUsage` | `boolean` | Ni événements ni sélection sur la ligne |
| `cellsAutoUpdated` | `boolean` | Réexécute `onBeforeCellRender` pour cette ligne quand ses événements changent |
| `minHeight`, `eventHeight`, `marginTop`, `marginBottom`, `maxLines`, `emptyHeight` | `number` | Géométrie de la ligne |
| `backColor`, `fontColor`, `cssClass`, `html`, `toolTip`, `bubbleHtml`, `ariaLabel`, `areas`, `contextMenu`, `tags` | divers | Présentation de l’en-tête et données |

### Liens, en-têtes, niveaux de zoom et séparateurs
| Type | Champs |
|---|---|
| `LinkData` | `from`, `to` (id d’événements), `id`, `type` (`'FinishToStart'` par défaut, `'FinishToFinish'`, `'StartToStart'`, `'StartToFinish'`), `color`, `width`, `style` (`'solid' \| 'dotted' \| 'dashed'`), `cssClass`, `layer`, `text`, `textAlignment`, `bubbleHtml`, `contextMenu` |
| `TimeHeaderData` | `groupBy` (`'Minute' \| 'Hour' \| 'Day' \| 'Week' \| 'Month' \| 'Quarter' \| 'Year' \| 'Cell' \| 'None' \| 'Default'`), `format`, `height` |
| `ZoomLevel` | `id`, `properties` (valeurs d’options, chacune éventuellement fonction de `{ date, level }`) |
| `SeparatorData` | `location`, `color`, `layer` (`'AboveEvents' \| 'BelowEvents'`), `opacity`, `width`, `cssClass`, `toolTip` |
| `TimelineData` | `start`, `end`, `width` (cellules pour `scale: 'Manual'`) |

## Options
### Axe du temps
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `startDate` | `DateInput` | aujourd’hui | Tronquée à minuit |
| `days` | `number` | `1` | Longueur de la frise |
| `scale` | `'CellDuration' \| 'Minute' \| 'Hour' \| 'Day' \| 'Week' \| 'Month' \| 'Year' \| 'Manual'` | `'CellDuration'` | `'Manual'` utilise `timeline` |
| `cellDuration` | `number` (minutes) | `60` | Avec `scale: 'CellDuration'` |
| `cellWidth` | `number` | `40` | Pixels par cellule de l’échelle courante |
| `cellWidthSpec` | `'Fixed' \| 'Auto'` | `'Fixed'` | `'Auto'` ajuste la frise à la largeur |
| `cellWidthMin` | `number` | `1` | |
| `timeHeaders` | `TimeHeaderData[]` | `[{ groupBy: 'Default' }, { groupBy: 'Cell' }]` | `'Default'` suit `cellGroupBy` |
| `cellGroupBy` | `GroupBy` | `'Day'` | |
| `headerHeight` | `number` | `30` | Par ligne d’en-tête |
| `timeFormat` | `'Auto' \| 'Clock12Hours' \| 'Clock24Hours'` | `'Auto'` | Libellés d’heures par défaut uniquement |
| `locale` | `string \| SuperScheduler.Locale` | `'en-us'` | N’importe quel identifiant de locale `Intl` |
| `weekStarts` | `'Auto' \| number` | `'Auto'` | `0` correspond à dimanche |
| `eventEndSpec` | `'DateTime' \| 'Date'` | `'DateTime'` | `'Date'` rend inclusives les fins exprimées en dates seules |
| `showNonBusiness` | `boolean` | `true` | `false` masque les week-ends (échelle en jours) ou les heures non ouvrées |
| `businessBeginsHour`, `businessEndsHour` | `number` | `9`, `18` | |
| `businessWeekends` | `boolean` | `false` | |
| `cellsMarkBusiness` | `boolean` | `true` | |
| `showCurrentTimeHeader` | `boolean` | `false` | |
| `separators` | `SeparatorData[]` | `[]` | Repères verticaux de date |
| `timeline` | `TimelineData[]` | aucune | Avec `scale: 'Manual'` |
| `infiniteScrollingEnabled` | `boolean` | `false` | `infiniteScrollingMargin` `50`, `infiniteScrollingStepDays` `30` |
| `floatingTimeHeaders` | `boolean` | `true` | Libellés d’en-tête collants |
| `viewType` | `'Resources'` | `'Resources'` | `'Days'` et `'Gantt'` sont réservés |
| `scrollX`, `scrollY` | `number` | aucune | Défilement initial en pixels |

### Lignes
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `resources` | `ResourceData[]` | `[]` | |
| `treeEnabled` | `boolean` | `false` | Requis pour `children` |
| `treeIndent` | `number` | `20` | |
| `treeAutoExpand` | `boolean` | `true` | |
| `treePreventParentUsage` | `boolean` | `false` | Les parents ne prennent ni événements ni sélection |
| `rowHeaderWidth` | `number` | `80` | |
| `rowHeaderWidthAutoFit` | `boolean` | `true` | S’élargit selon les noms ; `rowHeaderWidthMin` `20`, `rowHeaderWidthMarginRight` `0` |
| `rowHeaderColumns` | `RowHeaderColumnData[]` | aucune | Une colonne qui affiche `name` |
| `rowHeaderColumnsResizable` | `boolean` | `true` | `rowHeaderColumnDefaultWidth` `80`, `rowHeaderColumnsMergeParents` `true` |
| `rowHeaderColumnsReorderable` | `boolean` | `false` | Glisser les titres de colonnes |
| `rowMinHeight`, `rowEmptyHeight` | `number` | `0`, aucune | |
| `rowMarginTop`, `rowMarginBottom` | `number` | `0` | |
| `eventHeight` | `number` | `35` | Une ligne d’empilement |
| `eventMarginBottom` | `number` | `0` | |
| `rowFilterParentsAlwaysVisible` | `boolean` | `true` | |
| `rowSortingMode` | `'LeavesOnly' \| 'ParentsOnly' \| 'All'` | `'LeavesOnly'` | Utilisé par `rows.sort()` |
| `selectedRows` | `string[] \| number[]` | `[]` | |
| `cornerText`, `cornerHtml` | `string` | `''`, aucune | Cellule en haut à gauche |

### Événements et édition
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `events` | `EventData[]` | `[]` | Données contrôlées ; le tableau est adopté et modifié sur place avec splice |
| `defaultEvents` | `EventData[]` | aucune | Données initiales non contrôlées, lues une fois |
| `eventMoveHandling`, `eventResizeHandling` | `'Update' \| 'Notify' \| 'Disabled'` | `'Update'` | `'Disabled'` empêche le geste |
| `eventClickHandling` | `'Enabled' \| 'Select' \| 'ContextMenu' \| 'Bubble' \| 'Disabled'` | `'Enabled'` | `'Select'` bascule la sélection |
| `eventDoubleClickHandling` | mêmes valeurs | `'Disabled'` | Un handler de double-clic retarde les clics simples de `doubleClickTimeout` (`300`) |
| `eventRightClickHandling` | mêmes valeurs | `'ContextMenu'` | |
| `eventSelectHandling` | `'Update' \| 'Disabled'` | `'Update'` | |
| `eventDeleteHandling` | `'Update' \| 'Disabled'` | `'Disabled'` | `'Update'` ajoute un bouton de suppression au survol |
| `eventHoverHandling` | `'Bubble' \| 'Disabled'` | `'Bubble'` | Affiche `bubbleHtml` |
| `eventTapAndHoldHandling` | `'Move' \| 'ContextMenu' \| 'Disabled'` | `'Move'` | Tactile ; `tapAndHoldTimeout` `300` |
| `allowEventOverlap` | `boolean` | `true` | `false` refuse les déplacements, redimensionnements et sélections sur un temps occupé |
| `conflictHighlight` | `boolean` | `false` | Signale les événements en collision pendant le glissement |
| `useEventBoxes` | `'Always' \| 'Never' \| 'ShortEventsOnly'` | `'Always'` | `'Always'` dessine les événements sur des cellules entières |
| `eventMoveByCell` | `boolean` | `false` | Avec `useEventBoxes: 'Never'` |
| `moveBy` | `'Full' \| 'Top' \| 'Left'` | `'Full'` | Zone de prise pour le glissement |
| `eventMoveMargin`, `eventResizeMargin` | `number` | `5` | |
| `eventMoveSkipNonBusiness`, `eventMoveToPosition` | `boolean` | `false` | |
| `snapToGrid` (et `...EventMoving`, `...EventResizing`, `...TimeRangeSelecting`, `...RectangleSelecting`) | `boolean` | `true` | |
| `dragCard` | `boolean \| DragCardOptions` | `true` | Carte à côté du pointeur pendant le glissement |
| `headerMarker`, `resizeHandles` | `boolean` | `true` | |
| `autoScroll` | `'Drag' \| 'Always' \| 'Disabled'` | `'Drag'` | `autoScrollSpeed` `50`, `autoScrollDelay` `100` |
| `dragOutAllowed` | `boolean` | `false` | Glisser des événements vers des cibles de dépôt |
| `floatingEvents` | `boolean` | `true` | Libellés d’événements collants |
| `eventMinWidth` | `number` | `1` | |
| `eventBorderRadius`, `eventPadding` | `string \| number` | aucune | |
| `eventTextWrappingEnabled` | `boolean` | `false` | |
| `eventHtmlLeftMargin`, `eventHtmlRightMargin` | `number` | `10` | |
| `durationBarVisible` | `boolean` | `true` | `durationBarMode` `'Duration'` ou `'PercentComplete'` ; `durationBarHeight` aucune |
| `eventStackingLineHeight` | `number` | `100` | |
| `showToolTip` | `boolean` | `true` | Infobulles natives à partir de `toolTip` |
| `eventMovingStartEndEnabled`, `eventResizingStartEndEnabled`, `timeRangeSelectingStartEndEnabled` | `boolean` | `false` | Libellés à côté de l’ombre, format `'MMMM d, yyyy'` |
| `crosshairType` | `'Header' \| 'Full' \| 'Disabled'` | `'Header'` | |
| `xssProtection` | `'Enabled' \| 'Disabled'` | `'Enabled'` | Échappe `text` ; `html` n’est jamais échappé |

### Sélection
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `timeRangeSelectedHandling` | `'Enabled' \| 'Hold' \| 'HoldForever' \| 'Disabled'` | `'Enabled'` | Clics et glissements sur les cellules vides ; `'HoldForever'` conserve la sélection quand l’utilisateur clique ailleurs |
| `timeRangeClickHandling` | `'Enabled' \| 'Disabled'` | `'Enabled'` | Clics sur une plage sélectionnée |
| `timeRangeDoubleClickHandling` | `'Enabled' \| 'Disabled'` | `'Disabled'` | |
| `timeRangeRightClickHandling` | `'ContextMenu' \| 'Enabled' \| 'Disabled'` | `'ContextMenu'` | |
| `allowMultiRange`, `multiRangeMode` | `boolean`, `'CtrlOrMeta' \| 'Always'` | `false`, `'CtrlOrMeta'` | Plusieurs plages de temps |
| `allowMultiSelect` | `boolean` | `true` | Plusieurs événements sélectionnés |
| `eventMultiSelectRange` | `boolean` | `false` | Maj+clic sélectionne un bloc |
| `rectangleSelectHandling` | `'Disabled' \| 'Enabled' \| 'EventSelect'` | `'Disabled'` | |
| `rectangleSelectMode`, `rectangleSelectModifiers` | `'Free' \| 'Row'`, `boolean` | `'Free'`, `false` | |
| `allowMultiMove`, `allowMultiResize` | `boolean` | `false` | `multiMoveVerticalMode` `'Disabled'` |
| `rowClickHandling` | `'Enabled' \| 'Select' \| 'Disabled'` | `'Enabled'` | |
| `rowDoubleClickHandling` | `'Enabled' \| 'Select' \| 'Disabled'` | `'Disabled'` | |
| `rowRightClickHandling` | `'ContextMenu' \| 'Enabled' \| 'Disabled'` | `'ContextMenu'` | |
| `rowSelectHandling` | `'Update' \| 'Notify'` | `'Update'` | |
| `timeHeaderClickHandling` | `'Enabled' \| 'Disabled'` | `'Enabled'` | |
| `resourceExpandHandling`, `resourceCollapseHandling` | `'Enabled'` | `'Enabled'` | |

### Zoom et niveau de détail
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `zoomLevels` | `ZoomLevel[]` | `[]` | |
| `zoom` | `number \| string` | aucune | Niveau initial : index ou `id` |
| `zoomPosition` | `'left' \| 'middle' \| 'right'` | `'left'` | Point maintenu en place lors des changements de niveau |
| `zoomGesture` | `boolean \| ZoomGestureOptions` | `true` | Ctrl ou Cmd + molette, pincement ; options `min`, `max` (`400`), `wheel` (`'ctrl'`), `pinch` (`true`), `sensitivity` (`1`), `scales` (`'zoomLevels'`), `link` |
| `lod` | `boolean \| LodOptions` | `true` | Niveau de détail adaptatif |

### Taille et disposition
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `height` | `number \| '100%'` | `600` | Hauteur totale, en-têtes compris |
| `heightSpec` | `'Max' \| 'Fixed' \| 'Auto' \| 'Parent100Pct' \| 'Max100Pct'` | `'Max'` | `'Max'` : hauteur du contenu, jusqu’à `height` |
| `width` | `number` | aucune | Remplit l’hôte |
| `visible` | `boolean` | `true` | |

### Apparence
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `colorScheme` | `'inherit' \| 'light' \| 'dark' \| 'auto'` | `'inherit'` | Seul `'auto'` suit la préférence du système |
| `density` | `'comfortable' \| 'compact' \| 'dense'` | aucune | |
| `classNames`, `styles` | par slot (`root`, `event`, `cell`, `rowHeader`, ...) | `{}` | Classes ou styles inline |
| `cssClass` | `string` | aucune | Classe supplémentaire sur la racine |
| `unstyled` | `boolean` | `false` | Structure uniquement |
| `theme` | `string` | aucune | Ajoute des classes `{theme}_*` |
| `nowLine` | `boolean \| { interval, label, cssClass }` | `false` | Intervalle de `60000` ms |
| `emptyState`, `errorState` | `ReactNode \| Node` | aucune | Une chaîne est affichée comme texte |
| `loading` | `boolean` | aucune | `loadingLabelText` `'Loading...'`, `loadingLabelVisible` `true` |
| `messageHideAfter`, `messageHideOnMouseOut`, `messageBarPosition` | `number`, `boolean`, `'Top' \| 'Bottom'` | `5000`, `true`, `'Top'` | Pour `control.message()` |

### Liens
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `links` | `LinkData[]` | `[]` | Tracés à partir des données |
| `linkShape` | `'Curved' \| 'RightAngled'` | `'Curved'` | |
| `linkLayer` | `'Above' \| 'Below'` | `'Above'` | |
| `linkWidth` | `'Auto' \| number` | `'Auto'` | |
| `linkBottomMargin` | `number` | `17` | |

### Clavier
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `keyboardEnabled` | `boolean` | `false` | |
| `keyboardTarget` | `'document' \| 'component'` | `'document'` | |
| `keyboardMode` | `'SuperScheduler' \| 'Full'` | `'SuperScheduler'` | `'Full'` nécessite `keyboardEnabled` |
| `keyboardOptions` | `{ pageRows, contextMenuKey, bubbleOnFocus, selectAll, zoomKeys }` | aucune | `zoomKeys` vaut `false` par défaut |

### Menus et bulles
| Option | Type | Défaut |
|---|---|---|
| `contextMenu`, `contextMenuResource`, `contextMenuSelection`, `contextMenuLink` | `SuperScheduler.Menu` | aucune |
| `bubble` | `SuperScheduler.Bubble` | une bulle qui affiche `bubbleHtml` |
| `cellBubble`, `resourceBubble`, `linkBubble` | `SuperScheduler.Bubble` | aucune |
| `allowDefaultContextMenu` | `boolean` | `false` |

### Données, chargement et extensions
| Option | Type | Défaut | Remarques |
|---|---|---|---|
| `extensions` | `SchedulerExtension[]` | aucune | Chargeurs de plages, historiques |
| `history` | objet historique | aucune | Raccourci pour une extension d’historique |
| `dynamicLoading` | `boolean` | `false` | Avec `onScroll` |
| `scrollDelayDynamic` | `number` | `500` | Temps de calme avant `onScroll` |

### Contenu React
Uniquement avec le `SuperSchedulerComponent` de `super-scheduler/react-render` :

| Prop | Arguments | Renvoie |
|---|---|---|
| `renderEvent` | `{ control, e, data, row, width, lod }` | `ReactNode` |
| `renderCell` | `{ control, cell }` | `ReactNode` |
| `renderRowHeader` | `{ control, row, column }` | `ReactNode` |
| `renderTimeHeader` | `{ control, header }` | `ReactNode` |
| `renderArea` | `{ control, area, source }` (zones avec `render: true`) | `ReactNode` |
| `renderCorner` | `{ control }` | `ReactNode` |
| `eventHover` | `{ render, delay (350), leaveGrace (180), placement ('auto'), pin (false), glide (true) }` | |
| `renderOptions` | `{ retain, sliceMs (8) }` | |

## Callbacks
### Conventions
- **Avant et après.** `onEventMove` s’exécute avant une modification et peut l’annuler ; `onEventMoved` s’exécute après. La plupart des paires suivent ce modèle.
- **Annulation.** Les handlers dont les arguments ont `preventDefault()` peuvent annuler : la famille des clics, `onEventSelect`, `onEventDelete`, `onEventMove`, `onEventResize`, `onTimeRangeSelect`, `onTimeRangeClick` et ses variantes double-clic et clic droit, `onRectangleSelect`, `onRowClick` et ses variantes, `onRowSelect`, `onResourceExpand`, `onResourceCollapse`, `onTimeHeaderClick`, `onTimeHeaderRightClick`, `onGridMouseDown`, `onKeyDown`, `onKeyboardFocusChange` et `onLinkClick`. Annuler un clic empêche aussi son handler en « -ed » et l’action qui suit.
- **Confirmation asynchrone.** `onEventMove` et `onEventResize` prennent en charge `args.async = true` puis un appel ultérieur à `args.loaded()` ; `preventDefault()` avant `loaded()` annule, et `newStart`, `newEnd` et `newResource` définis avant `loaded()` sont appliqués.
- **Pilotage.** `onEventMoving`, `onEventResizing`, `onTimeRangeSelecting` et `onRectangleSelecting` s’exécutent à chaque changement de l’ombre ; affectez `args.allowed`, `args.start`, `args.end`, `args.cssClass` ou `args.html`.

### Événements
| Handler | Arguments | Annulation |
|---|---|---|
| `onEventClick`, `onEventClicked` | `{ e, div, control, originalEvent, ctrl, shift, meta }` | le premier |
| `onEventDoubleClick`, `onEventDoubleClicked` | `{ e, originalEvent }` | le premier |
| `onEventRightClick`, `onEventRightClicked` | `{ e, div, originalEvent }` | le premier |
| `onEventSelect`, `onEventSelected` | `{ e, selected, ctrl, meta }` | le premier |
| `onEventDelete`, `onEventDeleted` | `{ e, control }` | le premier |
| `onEventMouseEnter`, `onEventMouseLeave` | `{ e, div }` | non |
| `onEventFilter` | `{ e, filterParam, visible }` ; définissez `visible = false` | non |
| `onEventsChange` | `{ events, changed, removed, reason }`, `reason` parmi `'move'`, `'resize'`, `'create'`, `'remove'`, `'update'`, `'api'`, `'history'`, `'load'` | non |

`e` est un `SuperScheduler.Event` : `e.data` est l’objet de données, et `e.id()`, `e.start()`, `e.end()`, `e.text()`, `e.resource()` et `e.duration()` le lisent.

### Glisser et redimensionner
| Handler | Arguments | Annulation et asynchrone |
|---|---|---|
| `onEventMoving` | `{ e, start, end, duration, resource, row, allowed, allowOverlap, conflicts, message, cssClass, html, external, multimove, left, right, ctrl, shift, alt, meta }` | pilotage via `allowed` |
| `onEventMove` | `{ e, newStart, newEnd, newResource, external, multimove, control, position, async, loaded() }` | `preventDefault()`, asynchrone |
| `onEventMoved` | les mêmes valeurs, en lecture seule ; le store contient déjà les nouveaux horaires | non |
| `onEventResizing` | `{ e, start, end, what, row, allowed, allowOverlap, conflicts, message, ... }` | pilotage via `allowed` |
| `onEventResize` | `{ e, newStart, newEnd, what, multiresize, control, async, loaded() }` | `preventDefault()`, asynchrone |
| `onEventResized` | les mêmes valeurs, en lecture seule | non |

### Plages de temps et rectangles
| Handler | Arguments | Annulation |
|---|---|---|
| `onTimeRangeSelecting` | `{ start, end, anchor, duration, resource, row, allowed, overlapping, ignoreDisabledCells, html, cssClass, button }` | pilotage via `allowed` |
| `onTimeRangeSelect`, `onTimeRangeSelected` | `{ start, end, resource, control, origin, multirange }`, `origin` parmi `'click'`, `'drag'`, `'keyboard'`, `'api'` | le premier |
| `onTimeRangeClick`, `onTimeRangeDoubleClick`, `onTimeRangeRightClick` (et « -ed ») | `{ start, end, resource }`, sur une plage déjà sélectionnée | le premier |
| `onRectangleSelecting` | `{ events, start, end, resources, visible }` | pilotage via `visible` |
| `onRectangleSelect` | `{ events, start, end, resources, append }` | oui |
| `onRectangleSelected` | `{ events }` | non |
| `onGridMouseDown` | `{ action, originalEvent, button, ctrl, shift, meta }` ; définissez `action = 'None'` | oui |

### Lignes et en-têtes
| Handler | Arguments | Annulation |
|---|---|---|
| `onRowClick`, `onRowDoubleClick`, `onRowRightClick` (et « -ed ») | `{ row, x, originalEvent, ctrl, shift, meta }` | le premier |
| `onRowSelect`, `onRowSelected` | `{ row, selected, ctrl, shift, meta }` | le premier |
| `onRowFilter` | `{ row, filterParam, visible, control }` | non |
| `onRowMouseOver`, `onRowMouseOut` | `{ row, div }` | non |
| `onResourceExpand`, `onResourceCollapse` | `{ resource }` | oui |
| `onRowHeaderResized`, `onRowHeaderColumnResized` | `{}`, `{ column }` | non |
| `onRowHeaderColumnsChange` | `{ control, columns, order, widths, reason }` | non |
| `onRowSorted` | `{ oldSortParam }` | non |
| `onTimeHeaderClick`, `onTimeHeaderClicked` | `{ header: { start, end, level }, control, originalEvent, ctrl, shift, meta }` | le premier |
| `onTimeHeaderRightClick`, `onTimeHeaderRightClicked` | `{ header }` | le premier |
| `onCellMouseEnter`, `onCellMouseLeave` | `{ cell }` | non |

### Hooks de rendu
| Handler | Arguments | Ce que l’on modifie |
|---|---|---|
| `onBeforeEventRender` | `{ control, data }` | `data.backColor`, `fontColor`, `cssClass`, `html`, `areas`, `toolTip`, `height`, `hidden`... (une copie ; `start` et `end` sont des `SuperScheduler.Date`) |
| `onBeforeCellRender` | `{ control, cell, getPixels(date) }` | `cell.properties.backColor`, `cssClass`, `html`, `text`, `disabled`, `areas`, `bubbleHtml` |
| `onBeforeRowHeaderRender` | `{ row }` | `row.html`, `text`, `cssClass`, `backColor`, `areas`, `columns[i].html` |
| `onBeforeResHeaderRender` | `{ resource }` | Une copie de la ressource, champs de mise en page compris |
| `onBeforeRowHeaderColumnRender` | `{ column }` | `html`, `cssClass`, `areas` du titre de colonne |
| `onBeforeTimeHeaderRender` | `{ control, header }` | `header.html`, `text`, `cssClass`, `backColor`, `toolTip`, `areas` |
| `onBeforeCornerRender` | `{ control, html, areas }` | Contenu du coin |
| `onBeforeLinkRender` | `{ data, from, to }` | Couleur, épaisseur, style et `cssClass` du lien |
| `onIncludeTimeCell` | `{ cell: { start, end, visible, width } }` | Masquer ou redimensionner des cellules de la frise |
| `onAfterEventRender`, `onAfterCellRender` | `{ e, div }`, `{ cell, div }` | Le nœud peint |
| `onAfterRender`, `onAfterUpdate`, `onDimensionsChanged` | | Notifications de cycle de vie |

### Autres handlers
| Handler | Arguments |
|---|---|
| `onZoom` | `{ control, cellWidth, scale, cellDuration, phase, origin, anchor, viewportStart, level, lod }`, à chaque image d’un geste |
| `onHistoryChange` | `{ canUndo, canRedo, undoLabel, redoLabel, cause }` |
| `onScroll` | `{ viewport, async, events, remove, clearEvents, loaded() }`, avec `dynamicLoading` |
| `onKeyDown` | `{ originalEvent }`, annulable |
| `onKeyboardFocusChange`, `onKeyboardFocusChanged` | `{ previous, focus }` |
| `onLinkClick`, `onLinkClicked` | `{ link, originalEvent }`, `{ link }` |

## API du contrôle
Le contrôle est `ref.current.control`, la valeur de `controlRef`, `args.control` dans la plupart des handlers, ou `new SuperScheduler.Scheduler(element, options)` suivi de `init()`.

### Cycle de vie et affichage
| Membre | Description |
|---|---|
| `init()` | Requis une fois pour les contrôles impératifs ; `update()` avant `init()` lève une exception |
| `update(options?)` | Applique les options et redessine de façon synchrone ; sans arguments, rafraîchissement complet |
| `dispose()`, `disposed()` | Libération et état correspondant |
| `show()`, `hide()`, `setHeight(px)` | Visibilité ; `setHeight` passe à `heightSpec: 'Fixed'` |
| `message(text, delayOrOptions?)` | Barre de message dans le contrôle |
| `loadingStart(options?)`, `loadingStop()` | Libellé de chargement |
| `clearSelection()` | Efface la sélection de plage de temps |
| `dragInProgress()` | `true` pendant un geste |
| `levelOfDetail` | État courant du niveau de détail |
| `history` | L’historique attaché, ou `null` |
| `moveRowHeaderColumn(from, to)` | Réordonne les colonnes de l’en-tête de ligne |
| `nav` | Les éléments `top`, `scroll`, `corner`, `timeHeader`, `message` et `loading` (`null` avant `init()`) |
| `v` | Chaîne de version |

### Défilement et zone visible
| Membre | Description |
|---|---|
| `scrollTo(date \| px, animated?, position?)` | `animated` : `boolean`, ms, `'fast'`, `'normal'`, `'slow'` ou `'linear'` ; `position` : `'left'`, `'middle'`, `'right'` |
| `scrollToResource(id \| row)` | |
| `setScroll(x, y)`, `setScrollX(x)`, `setScrollY(y)`, `getScrollX()`, `getScrollY()` | Défilement en pixels |
| `getViewPort()` | `{ start, end, resources, rows(), events() }` de la zone visible |
| `visibleStart()`, `visibleEnd()` | Début et fin de la frise, pas de la zone visible |
| `getDate(px, precise?, isEnd?)`, `getCoords()` | Correspondance avec les pixels et le pointeur |
| `infinite.scrollTo(date)`, `infinite.shiftStart(days)` | Défilement infini |

### Événements
| Membre | Description |
|---|---|
| `events.list` | Le tableau de données, par référence |
| `events.add(event)` | Lève une exception en cas d’id en double |
| `events.update(event)` | Remplace un événement chargé ; sans effet pour un id inconnu |
| `events.remove(event \| id)` | |
| `events.find(id \| predicate)`, `events.findAll(predicate \| example)` | Recherches qui renvoient des `SuperScheduler.Event` |
| `events.all()`, `events.forRange(start?, end?)` | Tous les événements, ou ceux qui chevauchent une plage (par défaut, la plage visible) |
| `events.filter(param)` | Exécute `onEventFilter` |
| `events.scrollIntoView(event)` | |

### Lignes
| Membre | Description |
|---|---|
| `rows.add(data)`, `rows.addChild(parent, data)`, `rows.update(row \| data)`, `rows.remove(row \| id)` | Modifications de lignes |
| `rows.find(id \| predicate)`, `rows.all()`, `rows.visible()`, `rows.each(fn)` | Recherches qui renvoient des `SuperScheduler.Row` |
| `rows.expand(level?)`, `rows.expandAll()`, `rows.collapseAll()` | État de l’arborescence |
| `rows.filter(param)` | Exécute `onRowFilter` |
| `rows.sort(spec?)`, `rows.sortParam` | Tri (`{ field, order }`) |
| `rows.selection.add/remove/clear/get/isSelected` | Sélection de lignes |

### Sélection
| Membre | Description |
|---|---|
| `multiselect.add/remove/clear/get/events/isSelected/redraw` | Sélection d’événements |
| `multiselect.selectAll({ scope, filter })` | `scope` vaut `'view'` (par défaut) ou `'all'` |
| `multiselect.startRectangle()` | Arme la sélection par rectangle |
| `multirange.add(selection)`, `multirange.get()`, `multirange.clear()` | Plages de temps (`new SuperScheduler.Selection(start, end, resource)`) |
| `selectTimeRange(start, end, resource, dontFireEvent?)` | Sélectionne une plage |

### Zoom, liens, cellules et clavier
| Membre | Description |
|---|---|
| `zoom.active` | Index du niveau actif (`-1` avant tout niveau) |
| `zoom.setActive(level, position?, anchorDate?)` | Applique un niveau immédiatement |
| `zoom.animateTo({ level } \| { cellWidth }, { duration (300), position, anchorDate })` | Animé ; renvoie une promesse |
| `zoom.step(delta, options?)` | Un niveau, ou un facteur de 1,6 sans niveaux |
| `links.list`, `links.add`, `links.update`, `links.remove`, `links.find`, `links.findByFromTo`, `links.findAllByFromTo` | Liens |
| `cells.all()`, `cells.find(start, resource)`, `cells.findXy(x, y)`, `cells.findByPixels(x, y)` | Cellules montées |
| `keyboard.focusCell`, `focusEvent`, `getFocus`, `move`, `clearFocus`, `resetFocus` | Focus clavier |

### Membres statiques
| Membre | Description |
|---|---|
| `SuperScheduler.Scheduler.makeDraggable({ element, data, duration, ... })` | Glisser des éléments DOM dans la grille pour créer de nouveaux événements |
| `SuperScheduler.Scheduler.registerDropTarget({ element, onDrop, ... })` | Déposer des événements hors de la grille (avec `dragOutAllowed`) |
| `SuperScheduler.Scheduler.startDragging(options)`, `stopDragging()` | Glissement externe programmatique |

## L’espace de noms SuperScheduler
| Membre | Description |
|---|---|
| `Date` | Date et heure civiles : `today()`, `now()`, `parse(text, pattern, locale?)`, `fromYearMonthDay()`, `add*()`, `firstDayOf*()`, `getDatePart()`, `getDay()` (jour du mois), `getDayOfWeek()`, `dayOfWeekISO()`, `weekNumberISO()`, `toString(pattern?, locale?)`, `toDate()`, `toDateLocal()`, `value`, `ticks`, `equals()` |
| `Duration` | Durée en millisecondes : `ofDays()`, `ofHours()`, `ofMinutes()`, `totalHours()`, `toString(pattern?)` |
| `Event` | Wrapper d’événement (`data`, `id()`, `start()`, `end()`, `text()`, `resource()`, `duration()`) |
| `Locale` | `register(locale)`, `find(id)`, `new Locale(id, fields)` |
| `Menu`, `Bubble` | Menus contextuels et bulles au survol (`show()`, `hide()`) |
| `Selection` | `new Selection(start, end, resource?)` |
| `Util` | `escapeHtml(text)`, `overlaps(start1, end1, start2, end2)` (semi-ouvert) |
| `ColorUtil` | `darker()`, `lighter()`, `contrasting()` |
| `Exception` | Levée en cas de mauvaise utilisation de l’API |
| `guid()` | UUID v4 aléatoire |
| `Row`, `RenderRow`, `Link` | Créés par le contrôle ; lisez-les dans les handlers |

## Modules par sous-chemin
### history
`createHistory(options?)` renvoie un historique à passer via `history={history}` ou dans `extensions`. Options : `limit` (`50`), `record` (`['move', 'resize']`), `keys` (`'root'`, `'document'` ou `false` ; `'root'` par défaut), `equals`, `fields`, `apply` (`'control'` ou une fonction pour les événements contrôlés) et `labels`. Méthodes : `undo()`, `redo()`, `clear()`, `push({ label, undo, redo })`, `record({ ops, control })`, `batch(label, run)`, `revert(eventId)`, `subscribe(listener)` ; propriétés `canUndo`, `canRedo`, `undoLabel`, `redoLabel`. Les chargements et les modifications refusées ne sont pas enregistrés.

### minimap
`createMinimap(control, container, options?)` et le composant React `<SchedulerMinimap control={control} />`. Options : `series` (par défaut `eventDensity(control)`), `height` (`28`), `peak` (`'relative'`, ou `'absolute'` avec `max`), `tone`, `marks` (`today`, `months`, `past`, tous à `true`), `range` et `labels`. Le widget dispose de `update()`, `refresh()` et `dispose()`.

### panes
`<SchedulerPanes>` accepte les props du planificateur plus `panes` (`{ id, resources or rowFilter, size, minSize (48), hidden, props }`), une `height` numérique obligatoire, `timeHeader` (`'first'`), `scrollbar` (`'last'`), `splitter` (`true`), `crossPaneMove` (`true`), `component`, `onPaneResize` et `panesRef`. `linkPanes(controls, { zoom, rowHeaderWidth })` relie des contrôles existants et renvoie `{ dispose() }`.

### zoom-ui
`createZoomHud(control, { format, apiMs (700) })`, `createZoomSlider(control, container, { min, max, detents, scale ('log'), label })` et `createLodBadge(control, container, labels?)`. Chacun renvoie `{ element, dispose() }`.

### views
`getViewState(control, include?)` renvoie un état sérialisable en JSON (`zoom`, `scroll`, `density`, `collapsed`, `columns`) ; `applyViewState(control, state, { animate, when, timeout })` (`when` vaut `'now'` ou `'rows'`) renvoie une promesse de `boolean`.

### ranges
`createRangeLoader({ load, chunkDays (7), prefetch (1), cacheChunks (26), skeleton (true), onError })` renvoie un chargeur doté de `reload(range?)`, `clear()` et `loading`. `load({ start, end, signal })` renvoie les événements qui chevauchent `[start, end)`.

### hooks
`useScheduler({ track })` renvoie `{ controlRef, control, state }` pour les sujets `'events'`, `'selection'`, `'zoom'`, `'viewport'` et `'history'`. `useSchedulerState(control, topic)`, `subscribeScheduler(control, topic, listener)` (qui renvoie une fonction de désabonnement) et `getSchedulerSnapshot(control, topic)` donnent le même état hors du hook. L’état de la zone visible est publié une fois le défilement stabilisé.

### react-render
`SuperSchedulerComponent` avec les [props de contenu React](#options-react-render). Le repli HTML ou texte est peint en premier ; le contenu React le remplace après la fin de l’interaction. `renderOptions.retain` vaut par défaut le plus petit de 2 000 ou du double des éléments montés ; `sliceMs` vaut `8`.

### tailwind
Un preset Tailwind CSS v3 : `presets: [require('super-scheduler/tailwind')]`. Il ajoute des couleurs, rayons, ombres et transitions `super-scheduler` associés aux tokens CSS.

### datasets
`generateDataset(options)` et `generateScenario(id, overrides?)` créent des données déterministes de type hôtelier (`rows` et `days` obligatoires, `seed`, `start` en ticks, `density`, `events`, `times`). `toSuperSchedulerData(dataset)` renvoie `{ resources, events }`. Scénarios : `S1` (120 lignes, 730 jours), `S2` (1 000 lignes, 730 jours), `S3` (5 000 lignes, 1 500 jours) et leurs variantes denses. Par défaut, les données commencent le 2026-01-01.

### core
Utilitaires sans DOM partagés par le moteur : `SchedulerDate`, `Duration`, `registerLocale`, `resolveLocale`, `formatTicks`, `parseTicks`, `ticksFromParts(year, month, day, ...)`, `partsOf`, `formatIso`, `parseIso`, `todayTicks`, `nowTicks`, les constantes `MS_PER_*`, ainsi que des utilitaires de frise, d’index et de mise en page. Utilisez-le pour des graphiques et des outils placés à côté du planificateur.

## API Lite
`super-scheduler-lite` est une frise journalière en lecture seule. Les options qu’il n’implémente pas lèvent `SuperScheduler Lite: unsupported option "..."`, dans tous les builds.

| Option | Type | Défaut |
|---|---|---|
| `startDate` | `DateInput` | aujourd’hui |
| `days` | `number` (entier) | `31` |
| `scale` | `'Day'` | `'Day'` |
| `cellWidth` | `number` | `64` |
| `height` | `number` | `400` |
| `rowHeaderWidth` | `number` | `160` |
| `rowMinHeight` | `number` | `40` |
| `eventHeight` | `number` | `26` |
| `resources` | `{ id, name }[]` (plate) | `[]` |
| `events` | `{ id, resource, start, end, text, backColor?, fontColor?, cssClass?, toolTip?, tags? }[]` | `[]` |
| `locale` | `string` | `'en-us'` |
| `ariaLabel` | `string` | `'Resource schedule'` |
| `emptyState` | `string` | `'No resources'` |
| `onEventClick` | `({ control, e: { data }, originalEvent }) => void` | aucune |
| `onTimeRangeClick` | `({ control, start, end, resource, originalEvent }) => void`, sur toute cellule vide | aucune |
| `controlRef` | objet ref ou `(control \| null) => void` | aucune |

Le contrôle (`ref.current.control`) dispose de `init()`, `update(options)`, `dispose()`, `disposed()`, `scrollTo(date)`, `scrollToResource(id)`, `visibleStart()` et `visibleEnd()`. L’espace de noms contient `SuperScheduler.Date` et `SuperScheduler.Scheduler`. Les champs de ressource `children`, `frozen`, `split` et `columns` sont rejetés. Tokens de thème sur `.super-scheduler-lite` : `--super-scheduler-background`, `-text`, `-border`, `-header`, `-event` et `-focus`. Voir [Passer de Lite à Pro](https://superscheduler.org/fr/docs/migrate-lite-to-pro/).

## API réservées
Ces membres sont typés pour que le code existant compile, mais ils ne sont pas implémentés dans la 0.1.0. Ils ne font rien, renvoient des valeurs vides et affichent `super-scheduler: <feature> is not supported yet` une seule fois dans les builds de développement.

| Domaine | Réservé |
|---|---|
| Édition en ligne | `eventEditHandling`, `eventEditMinWidth`, `rowEditHandling`, valeurs `'Edit'` des options de gestion des clics, `events.edit()`, `rows.edit()`, `Row.edit()`, `onEventEdit`, `onEventEdited`, `onEventEditKeyDown`, `onRowEdit`, `onRowEdited`, `onAfterEventEditRender` |
| Création et déplacement de lignes | `rowCreateHandling`, `rowCreateHeight`, `rowCreateHtml`, `rowCreateText`, `rowMoveHandling`, `rowMoveSameLevelOnly`, `rowDragHandleWidth`, `onRowCreate`, `onRowCreated`, `onRowMove`, `onRowMoved`, `onRowMoving`, `makeDraggableAsRow`, `registerRowDropTarget` |
| Création interactive de liens | `linkCreateHandling`, `linkDotSize`, `linkPointSize`, `onLinkCreate`, `onLinkCreated` (les liens sont tracés à partir des données `links`) |
| Allers-retours serveur et chargement HTTP | valeurs de gestion `'CallBack'` et `'PostBack'` et actions de menu correspondantes, `backendUrl`, `eventsLoadMethod`, `rowsLoadMethod`, `linksLoadMethod`, `events.load()`, `rows.load()`, `links.load()`, `blockOnCallBack`, `notifyCommit`, `clientState`, `onCallBackStart`, `onCallBackEnd`, `onLoadNode` |
| Rafraîchissement automatique | `autoRefreshEnabled`, `autoRefreshInterval`, `autoRefreshMaxCount`, `autoRefreshCommand`, `autoRefreshPause()`, `autoRefreshStart()`, `onAutoRefresh` |
| Export | `exportAs()`, `exceljs`, `onBeforeEventExport`, `onBeforeCellExport`, `onBeforeRowHeaderExport`, `onBeforeTimeHeaderExport`, `onBeforeCornerExport` |
| Versions et regroupement d’événements | `eventVersionsEnabled`, `eventVersionHeight`, `eventVersionMargin`, `eventVersionPosition`, `eventVersionsReserveSpace`, `groupConcurrentEvents`, `groupConcurrentEventsLimit`, `groupBubble`, `onBeforeGroupRender`, `row.groups` |
| Récurrence | `events.findRecurrent()` (renvoie `null`) |
| Vues et disposition | `viewType: 'Days'` et `'Gantt'` (rendus comme `'Resources'`), `layout`, `rowHeaderScrolling`, `rowHeaderColumnsMode`, `rowHeaderHideIconEnabled`, `rows.headerHide()`, `rows.headerShow()`, `rows.headerToggle()`, `timeHeaderTextWrappingEnabled`, `sortDirections`, `syncResourceTree` |
| Autres | `api`, `eventBubbleShowForMargins`, `hideBorderFor100PctHeight`, `hideUntilInit`, `initEventEnabled`, `jointEventsMove`, `jointEventsResize`, `navigatorBackSync`, `overrideWheelScrolling`, `scrollStep`, `watchWidthChanges`, `range` et `range.all()` (utilisez `multirange`), `events.focus()`, `uiBlock()`, `uiUnblock()`, `onBeforeGridLineRender`, `onResourceHeaderClick`, `onResourceHeaderClicked`, `SuperScheduler.Navigator`, `Row.column(i).html(value)`, `onDomAdd` et `onDomRemove` de `Bubble` |

Partiellement implémentés :

- `treeAnimation` est accepté, mais l’animation de dépliage n’est jamais jouée.
- `eventClusters` et `onClusterClick` sont acceptés et n’ont encore aucun effet visible.
- Les handlers `onBefore*DomAdd` et `onBefore*DomRemove`, les props `render*` et `eventHover` ne fonctionnent qu’avec le composant de `super-scheduler/react-render` ; le composant racine émet un avertissement et les ignore.

Indications de réglage acceptées mais ignorées, car la virtualisation est toujours active et se règle d’elle-même : `beforeCellRenderCaching`, `cellSweeping`, `cellSweepingCacheSize`, `drawBlankCells`, `dynamicEventRendering` et ses options de marge et de cache, `eventUpdateInplaceOptimization`, `progressiveRowRendering`, `progressiveRowRenderingPreload` et les options `scrollDelay*` autres que `scrollDelayDynamic`.