Temporeum Timelinev1.0.2

Changelog

Every release of the six packages, newest first. The source of each section is the package's own CHANGELOG.md, which ships with it. 1.0.0 is the first release.

@temporeum/timeline-core

1.0.2 — 2026-11-09

Fixed

  • An era's name is in the axis band, as near the middle of what is seen of the era as the dates leave room — shortened with an ellipsis if only that fits. It was at the top of the lane area, where the first row's items are drawn over it. A now line and a marker keep their place in the band, and the era's name goes round them. Without room in the band, not even shortened, the name stays at the lane area's top, as before. The same holds for a background item's label (/items), which is drawn like an era's.
  • Down a vertical timeline, a label placed after its item starts the label padding past it, as it does across. It started at the item's end: a point's label (/items) began two pixels past the dot's centre, and the dot's lower half lay on the text. The gap is the item's own room, so a label never leaps over an item that sits in it. Across, nothing changes.

Changed

  • The size budgets leave room: at least 10% and at least 750 B over the size when they were set, rounded up to the next half kB. The engine's is 35.5 kB (was 31.6 kB); /dom 5 kB, /groups 2.5 kB, /items 5.5 kB, /gantt 5 kB, /tools 6.5 kB, /export 9 kB, /intl 4.5 kB, /calendar 14.5 kB, /vis-compat 7 kB and /story 6.5 kB on top of it. The sizes themselves are what they were: the engine is 31.9 kB.
  • The heap growth over the throttled benchmark's pan may be 6.5 MB (was 5.2 MB, half the +10.4 MB measured before 1.0): 1.0.0 and 1.0.1 measure +5.3 MB alike, a browser's heap moving by a few per cent from one machine to the next.

1.0.1 — 2026-11-09

Fixed

  • The keyboard's focus ring follows a point's dot and a milestone's diamond. It was a rounded rect round the item's box: on a dot, a tall oval beside it, the box being as tall as the row and starting at the dot's centre. A new render hook, renderFocus, draws the ring of an item whose shape is not its box; /items gives a point a circle round its dot, /gantt a milestone a diamond round its diamond, and every other item keeps the default ring.
  • The /items entry point's budget is 4.5 kB on top of the engine (was 4.25 kB): the point's ring is 40 B over the old one.
  • A vertical timeline's lane headers (/tools) are a line of text at the top of their column, as wide as the name. The plate was turned with the axis: as tall as the name and a line wide, it stood over the column's first items. A plate wider than its lane starts at the lane, not before it.

1.0.0 — 2026-11-07

The first release. From here on the package follows semantic versioning: nothing public is removed before 2.0.

The engine (@temporeum/timeline-core)

  • The (main, cross) projector, the time scale and an adaptive axis: round ticks from milliseconds to millennia, in the reader's time zone, with daylight saving handled, without a date library. Hidden time as a TimeWarp (RenderOptions.hiddenDates), and the axis's ticks from a source of the host's (RenderOptions.ticks).
  • Layout: collision-free packing in time, lanes, pinned lanes, sublane spans, open intervals, granularity-aware instants; cached per items array, or given by the host (RenderOptions.layout).
  • Rendering: a DOM-free scene and renderToSvgString; themes as CSS custom properties, light and dark, contrast-checked, and a host's own tokens refused unless each is a colour (a token never writes a rule); density levels; labels placed, shortened with an ellipsis where they do not fit whole (labelOverflow), and reported; decorations (banding, now, eras, markers).
  • Input: one pointer pipeline for mouse, pen and touch — pan, pinch, double tap (two taps of the same pointer type: on a hybrid device a finger's tap and a mouse's click are not one), two-finger tap, wheel (a run of wheel steps is one gesture) — anchored to the instant under each pointer, also where minSpanMs or maxSpanMs stops the zoom; cooperative touch.
  • Editing: move, resize, snap, canMove, cross-lane moves, multi-select, and reversible commands with an inverse. A grid of whole days lies on the wall clock of the timeZone the snap is given.
  • Responsive: orientation, density and detail surface resolved from the container; pointer-aware hit slop.
  • Performance: the scene space — tiles a sixteenth of a viewport, a deep zoom that re-anchors a step at a time, an overscan that grows while the view rests — with culling, node reuse and pooling in mountScene, and createFrameLoop.
  • The axis's context label: the month a view of days is in (the year of a view of months, the day of a view of hours), held at the start of the axis over a surface the ticks slide under — formatTick writes it too, with tick.context set; axisContext: false turns it off.
  • Accessibility: a listbox with aria-activedescendant, a keyboard twin for every gesture, reduced motion. The timeline's focus ring is drawn inside its box, so a parent with overflow: hidden cannot cut it. In forced colours (Windows High Contrast) every token is a system colour, the plugins' shapes included, and what is selected or focused is the highlight, drawn wider. An item's dates are read with their era before year 1 ("15 Mar 44 BC", not "15 Mar 44"). The root's letter and word spacing carry a 1 ms transition, so a host learns from its transitionend that a reader's spacing (WCAG 1.4.12) came or went, and can measure its labels again.
  • Data: createItemLoader, windowed and aborting. Clusters at dense zoom, with clusterZoom.
  • Server rendering: mountScene(container, { hydrate: true }) adopts a server-rendered <svg>.
  • A strict Content-Security-Policy and Trusted Types: mountScene puts a scene's <style> into the adoptedStyleSheets of the container's document or shadow root and writes style attributes through the CSSOM, so style-src needs no 'unsafe-inline'; where a sheet cannot be adopted it writes the <style> with MountOptions.nonce. mountPrintView builds the print view with the DOM, not markup, its stylesheet adopted too (nonce as the fourth argument for the fallback).
  • A host's className — on an item, a decoration, an arrow or a calendar event — is its own classes: a tl- class in data is left out, as it is from a template.
  • Time zones: a wall-clock time that happens twice is the first of the two, east and west of Greenwich alike (Temporal's "compatible"), so the ticks of the hour the clocks go back skip nothing; a zone's offsets are remembered by the hour, so a layout in a zone costs about what it does in UTC.
  • A zoom that comes back to where it started — a wheel run in and out — lands on the scale it left to within floating-point noise, and the scene space takes that for the scale: in the gesture it steps back onto it, and at rest it settles there around the same origin instead of drawing everything anew; of two scales as near, the tiles already on screen stand in.
  • VERSION is "1.0.0".

Entry points

The engine keeps a budget of 31.6 kB minified and gzipped. Everything else is on an entry point of its own, budgeted by what it adds on top of the engine, and a page downloads only the ones it imports. entries.json lists them; the build, the exports map and the size checks follow from it.

  • /dom — the browser binding: attachInput (mirrored for right to left), mounting and hydration.
  • /gantt — dependencies (FS, SS, FF, SF, with a lag or a lead) routed as arrows in both orientations and culled to the view; progress, baselines and milestones; the task grid's rows and keys; accessible names that say what a task depends on.
  • /schedule — scheduleTasks: dependencies, eight kinds of constraint, working calendars (WorkCalendar, workTime), slack and the critical path, conflicts and cycles. scheduleCommand turns the result into one command, undone by its inverse.
  • /resources — load against capacity (resourceLoad, loadAt, overloads), load lanes, overbooked assignments, and the backlog of unscheduled tasks.
  • /groups — nested groups as header lanes, collapsing, reordering as commands, and the keys of a WAI-ARIA tree.
  • /items — item kinds (box, point, background); adding and removing as commands, with vetoes; drops; HTML templates, sanitised by a DOM-free parser against an allow-list: a widened list still keeps only safe addresses and styles that load nothing, never <base>, <meta>, <link> or <form>, and never the timeline's own data-tl-* attributes and tl-* classes.
  • /tools — hidden dates (fixed and repeating, on a zone's wall clock), time bars, the overview strip, range selection, rolling mode, zoom presets and lane headers.
  • /live — live data: applyItemChanges and relayout, which packs only the lanes a change touched.
  • /words — the library's words in English: DEFAULT_STRINGS, resolveStrings, sayIn, fill, formatAmount.
  • /intl — right to left (mirrorScene, mirrorCss), dictionaries (describeHooks, pseudoStrings to find a word a translation missed), and the axis in any calendar Intl knows (calendarTicks).
  • /calendar — RFC 5545 recurrence (parseRRule, formatRRule, occurrences), events and their expansion, iCalendar read and written (parseICal, formatICal), and the layout of the week and the day. A zone matched by its VTIMEZONE rules is the one its Windows name means (Eastern Standard Time is America/New_York), and a limit counts only the starts it gives, not the excluded ones. One expansion of many events shares one search budget, so rules that never match cost what one does; formatICal writes UNTIL in the start's form (a date beside a date, a UTC time beside a time). A VTIMEZONE covers the years its zone's events reach, zoneYears (10) past each start at most, so a rule to the year 9999 cannot make it thousands of years long.
  • /export — print pages across the whole range, a PDF writer of the library's own (scenesToPdf, with selectable text), standalone SVG and PNG, and the print view.
  • /vis-compat — fromVis(items, groups, options): a vis-timeline 8 setup as a configuration, with a warning for everything that did not carry over; parseVisTime reads times by vis-timeline's rules.
  • /story — TimelineJS's JSON and Google Sheets template as items, lanes and eras (below).

Styling

  • RenderOptions.metrics (MetricsProvider): the sizes a frame draws, packs and measures with, by level and orientation — densityMetrics by default. fitDensity decides auto with them, the lane headers and the printed pages draw with them.
  • partNames and withParts (/dom), and MountOptions.parts: every node's classes as its parts, without the tl- prefix (item item-selected, timeline), a host's own class as it is — written by the mount where a class changed, for a drawing in a shadow root.
  • slotHooks (/items): an empty box over each item, for a framework to render into.

Stories (@temporeum/timeline-core/story)

  • fromTimelineJS: TimelineJS's JSON as items, lanes and eras — each event's slide in data.story, a lane per group, the eras as era decorations, the title slide apart — with a warning for everything that does not carry over (background-image, cosmological, no-date, out-of-range, end-before-start, duplicate-id). A negative year is the year before Christ TimelineJS writes (-44 is 44 BC); a null field is one not given, and a number where text goes is its digits.
  • fromTimelineSheet, readTimelineSheet, parseCsv, sheetCsvUrl: TimelineJS's Google Sheets template, read from the CSV the sheet publishes.
  • storyMedia: a media link sorted by its address — an image, a video, a sound file, a YouTube (without cookies), Vimeo (without tracking), SoundCloud, Spotify or Google Maps player, or a link.
  • storyDateText: a slide's date written to its precision, a span by its ends, a year before 1 AD with its era.

Packaging

  • ESM, CommonJS and UMD builds — the UMD files, for a <script> tag, minified; code shared between entry points ships once (dist/chunks/). CommonJS types (.d.cts) and typesVersions for moduleResolution: "node10".
  • Zero runtime dependencies. MIT. Published with npm provenance, unless 1.0.0 has to be created by hand first (stability).

@temporeum/timeline-element

1.0.2 — 2026-11-09

On 1.0.2 of @temporeum/timeline-core.

Fixed

  • An era's name (decorations) is in the axis band, where the items cannot cover it — the core's fix.
  • Down a vertical timeline, a point's label starts past its dot, not under it — the core's fix.

Changed

  • The element's size budget is 58.5 kB with the engine (was 53 kB), the UMD file's 116 kB (was 106 kB): room of at least 10% over the size, so a fix is not a hunt for bytes. The sizes are what they were.

1.0.1 — 2026-11-09

On 1.0.1 of @temporeum/timeline-core.

Fixed

  • The keyboard's focus ring on a point is a circle round its dot, on a Gantt milestone a diamond round its diamond, not a tall oval beside them.
  • A vertical timeline's lane headers (laneHeaders: true) sit at the top of their column, a line of text as wide as the name, not over the column's first items.

1.0.0 — 2026-11-07

The first release, on 1.0.0 of @temporeum/timeline-core. From here on the package follows semantic versioning: nothing public is removed before 2.0.

The timeline

  • createTimeline(container, config): the live timeline. It measures, draws once per frame in the engine's scene space, and takes pointer, wheel and keyboard input. It also covers editing, async items and clusters, and an external store (subscribe, getSnapshot) that notifies at most once per frame, and at once when the selection or the focus changes: a selectionChanged listener, or a caller right after focusItem, reads the new state from getSnapshot() and the element's selectedIds.
  • The host: a container that is not positioned is made position: relative while the timeline lives (and let go of at destroy()), so the tools and the group layer lie on the drawing and not on whatever ancestor is positioned. The default tooltip reads dates before year 1 with their era.
  • The instance:
  • live data: addItems, updateItems, removeItems, changeItems;
  • commands: applyCommand(command), undone with command.inverse;
  • focus and scroll: focusItem, scrollLanes, revealLane;
  • exportSvg();
  • update(config) compares the option objects, domain and selectedIds by what they say: a host that hands its props again on every render neither restarts a drag nor moves the view back. A new fetch function for items is called from the next fetch on; setItems reloads.
  • The instance inherits from a frozen Timeline prototype, so a framework's reactive proxy does not wrap it.
  • Plugins are registered once for the page: the registry lives on the global object under a registered symbol, so two copies of the element of one release (its ESM and CJS builds, or two bundles) share it. Each release has its own: a copy of another release — a CDN build beside a bundle — never draws with plugins whose internals it does not know, and says which import it lacks. The core is a ^1.0.0 dependency.
  • Types: the data a host writes and the payloads it reads come from the element too — Item, Lane, Command and ItemPatch (an undo stack's), the payloads — so a host or an adapter that installs only the element types everything with what it installed. TimelineInstance is Timeline by the name the adapters give it, where Timeline is the component.
  • Events: every event the instance emits is listed once in TIMELINE_EVENTS; the element and the framework adapters forward these. An item the timeline cannot read (no string id, a start or end that is not a time, a fractional sublaneSpan) is left out, a locale or timeZone the platform does not know falls back to the default, and so does a theme with a token that is not a colour; a decoration, a time bar or a hidden stretch of no known kind or with a time that is not one is left out of its list — on the client and the server alike — and inputSkipped (input-skipped) says which, so one bad item does not take the whole frame.
  • <temporeum-timeline>: moved in the document (an append into another parent, moveBefore, a framework reordering a list), it keeps its instance — view, selection, edits and listeners; removed, it lets go after the task's microtasks, and put back later it draws the items and the selection it was let go with. items, like domain and selectedIds, reads what is drawn, a drag or updateItems included. The getters and config read the JSON child too, under the attributes and the properties; a property or an attribute handed back falls back to it. Properties set before the element is defined go through its setters on upgrade. Every attribute has a property as its pair (start and end are domain), which wins over it until it is set to undefined; editable, multiSelect and snapMs are each one field of editing, so one set as a property leaves the others' attributes in force. config replaces what the config before it said; the tag is in HTMLElementTagNameMap and its events are typed (TimelineElementEventMap); a Custom Elements Manifest ships as dist/custom-elements.json, with each attribute's property, the theme's --tl-* tokens and the drawing's parts. element.focus() reaches the timeline (a delegating shadow root, on the server too), and aria-labelledby on the host names it by the text of the elements it points at — live, as the platform's is: a change to that text, or a label put in later, names it anew. Attributes (the accessible name is aria-label), properties, a JSON child for configuration (every date in it may be text: the items', the domain's, the decorations', the time bars', the hidden stretches', the limits'), kebab-case DOM events (the instance's command is timeline-command, clear of the platform's command event) and an open shadow root. /define registers it.
  • The options of the calendar view, the task grid, the backlog and the server renderers take an explicit undefined in every optional field, as the configuration does (exactOptionalPropertyTypes).
  • createTimeline's third argument turns the page-font measuring off with measureLabels: false (the configuration's measureText is the measuring function). groups given again with the same content keep the order the reader dragged them into. OBSERVED_ATTRIBUTES and STORY_STRINGS are frozen.
  • Server rendering: renderTimelineHtml and renderTimelineSvg, with a declarative shadow root, taken over on the client without drawing again. tagName must be a custom element name and attributes attribute names, never an on… handler; values are escaped.
  • Content Security Policy and Trusted Types: the timeline runs under style-src 'self' and require-trusted-types-for 'script'. Every stylesheet — the drawing's, the element's, the group tree's, the time tools', the story's, the backlog's, the task grid's, the calendar view's, the print view's — is a constructed sheet in adoptedStyleSheets, and every inline style goes through the CSSOM. nonce (the element's nonce attribute) is for the <style>s of the server's markup and of a browser without constructable sheets; renderTimelineHtml puts it on the element, not in the JSON, and the companions take it from timeline.nonce. The story's inert parse of TimelineJS's HTML goes through a temporeum-timeline Trusted Types policy (TRUSTED_TYPES_POLICY) kept inside the library, or the host's (trustedTypesPolicy). See the guide on Content Security Policy.
  • The base configuration:
  • items and lanes, theme, hooks;
  • labels: labelOverflow, maxLabels, formatTick;
  • touch: touchAction ("cooperative" leaves the page's scroll to the page);
  • editing: move, resize, snap, snapOrigin, minDurationMs, crossLane, canMove. A grid of whole days snaps to the timeline zone's midnights all year, and an item known to the day is resized by the edge it is drawn with.
  • axisContext (on by default): the month, year or day the view is in, at the start of the axis.
  • Text spacing (WCAG 1.4.12): labels are measured with the reader's letter and word spacing, read off a drawn label, and measured and laid out again when that spacing comes or goes after load, so a label keeps its whole text where its item has room.

Plugins

A plain timeline downloads only what it uses. The rest is a plugin on an entry point of its own, registered once for the page with registerPlugin(...plugins) (hasPlugin(name) asks). A configuration, a live change or a command that needs a missing plugin throws a TypeError naming the import, before anything changes. The <script>-tag build (timeline-element.umd.js) carries every plugin and registers them on load.

  • /gantt — ganttPlugin: the gantt option draws dependency arrows, progress, baselines and milestones, and [ and ] move the focus to a predecessor and a successor. mountTaskGrid is the table beside the chart: a role="grid" that keeps only the rows in view in the document.
  • /resources — resourcesPlugin: the resources and resourceOptions options, with load lanes, overload bands and overbooked assignments. mountBacklog holds the unscheduled tasks, placed by a drag or with Enter.
  • /export — exportPlugin: exportPng, exportPdf (the whole range, paginated) and print. Without the plugin their promises reject, naming the import; before the first frame every export, exportSvg included, says "Nothing drawn yet".
  • /tools — toolsPlugin: hiddenDates, timeBars, rolling, zoomPresets, minimap, rangeSelect, laneHeaders, tooltip, and the timeBarMoved and rangeSelected events.
  • /groups — groupsPlugin: nested groups as a role="tree" beside the drawing, collapsed and reordered by pointer and by key.
  • /items — itemsPlugin: box, point and background items, template (sanitised HTML), and editing.add, editing.remove and editing.drop.
  • /intl — intlPlugin: strings (every word the library says), calendar (the axis in a calendar Intl knows), and direction: "rtl" and "auto".
  • /calendar — not a plugin, nothing to register: mountCalendarView mounts a week or a day of events beside the timeline, with recurrence expanded for the period shown.

Styling

  • <temporeum-timeline> styled from the page. The tokens a page sets on the element reach the drawing (they are declared on :host in the shadow root), and every node of the drawing, the group tree and the time tools carries its classes as parts: temporeum-timeline::part(item-selected), ::part(urgent) for an item's className. A server-rendered element prints both; an export is drawn with the theme's own stylesheet.
  • metrics (SizeOverrides, MetricsSetting): a row's height, the gaps, the type sizes, the corners and the font stack over the density's, as configuration — the layout packs and measures with them, and density: "auto" decides with them. An object, or a function of the level's own sizes. A size nothing can be drawn at, or a font stack that would end the stylesheet's rule, is a RangeError where it is configured. timeline.metrics says what the last frame was drawn with.
  • slots: an empty box over each item (or those a function picks) for a framework to render into, with the /items plugin. timeline.slots and the slotsChanged event give each drawn item a host of its own — the same element while the item is drawn, through pans, zooms and live data — announced in the frame that drew it. ItemSlot, SlotsChangedPayload.

Stories (@temporeum/timeline-element/story)

  • mountStory: a panel that tells the items' slides one at a time beside the timeline — media, date, headline, text — with Previous and Next, ← → Home End, and each change said once. The panel and the timeline move together: a slide selects its item and brings it into view, a selection opens its slide. A title slide shows the whole story; hash names the slide in the address. Not a plugin: nothing to register.
  • Every mounted handle has the same verbs: update(options) changes the options given and keeps the rest (a companion — the calendar view, the task grid, the backlog, the story — draws again without options; the backlog's tasks are update({ tasks })); next() and previous() say whether there was one; events come through on(event, handler): the calendar view's itemSelect and rangeChanged, the story's slideChanged, the opening slide included. The story's update takes its words, theme, title slide, slide and hash, and stays on the slide shown.
  • A provider's player loads when the reader asks for it (media: "click", the default), by a button that names the host it loads from, in a sandboxed frame that cannot navigate the page.
  • storyHtml: TimelineJS's HTML kept as far as it is safe — text, emphasis, paragraphs, lists, quotes and links — rebuilt from an inert template, never assigned. storyCss, STORY_STRINGS.
  • The <script>-tag build carries the story panel.

Packaging

  • ESM and CommonJS builds, the /define subpath, and a self-contained, minified UMD file for a <script> tag. MIT. Published with npm provenance, unless 1.0.0 has to be created by hand first (stability).

@temporeum/timeline-react

1.0.2 — 2026-11-09

On 1.0.2 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • An era's name is in the axis band, where the items cannot cover it, not at the top of the lane area under the first row's items.
  • Down a vertical timeline, a point's label starts past its dot, not under it.

1.0.1 — 2026-11-09

On 1.0.1 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • The keyboard's focus ring on a point is a circle round its dot, on a Gantt milestone a diamond round its diamond.
  • A vertical timeline's lane headers sit at the top of their column, not over its first items.

1.0.0 — 2026-11-07

The first release, on 1.0.0 of @temporeum/timeline-element. From here on the package follows semantic versioning.

  • <Timeline>: every configuration field a prop, every instance event an on… prop (TIMELINE_EVENTS of the element); it does not re-render to draw.
  • registerPlugin and hasPlugin (and the TimelinePlugin type) are handed on from @temporeum/timeline-element, so an app that installs only the adapter registers the plugins it needs; the element is a ^1.0.0 dependency.
  • The view and the selection are defaults — defaultDomain and defaultSelectedIds — and stay where the reader moved them on a re-render; the instance's zoomTo and select move them. Every other field is compared by what it says: an option object written anew on each render is no change, and a drag in progress goes on.
  • useTimelineState(timeline, selector, isEqual?): subscribe to the part of the state a component renders, through useSyncExternalStore; a new selector reads the snapshot again.
  • The callbacks that run are the last committed render's; a new timelineRef gets the instance and the old one null; id, data-*, aria-*, role, title and ref are the box's, but aria-label names the timeline (ariaLabel), as on the element — ref on React 18 too, through forwardRef.
  • Server rendering and hydration without a second drawing; "use client" for the Next App Router.
  • Options that need a plugin of the element (gantt, resources, the time tools, groups, the item kinds, strings, calendar, direction) need it registered once for the page, with registerPlugin from @temporeum/timeline-element — in the app's entry, before the first timeline, and where the server renders too. Without it the configuration throws, naming the import.
  • For React 18 and 19 (the peer range is ^18.0.0 || ^19.0.0).
  • Every optional prop takes an explicit undefined, the box's (className, style, ssrWidth, renderItem …) as well as the configuration's, so a host forwarding its own optional value compiles under exactOptionalPropertyTypes.
  • renderItem: each item's content as React, rendered by a portal into the box over the item — it keeps its state and context while the item is drawn, and is unmounted when it leaves the view. Needs the element's /items plugin, registered once.
  • react-dom is a peer dependency (^18.0.0 || ^19.0.0, as react), for the portals.

@temporeum/timeline-vue

1.0.2 — 2026-11-09

On 1.0.2 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • An era's name is in the axis band, where the items cannot cover it, not at the top of the lane area under the first row's items.
  • Down a vertical timeline, a point's label starts past its dot, not under it.

1.0.1 — 2026-11-09

On 1.0.1 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • The keyboard's focus ring on a point is a circle round its dot, on a Gantt milestone a diamond round its diamond.
  • A vertical timeline's lane headers sit at the top of their column, not over its first items.

1.0.0 — 2026-11-07

The first release, on 1.0.0 of @temporeum/timeline-element. From here on the package follows semantic versioning.

  • <Timeline> and useTimelineState for Vue 3: every TimelineConfig field as a declared, typed prop (TimelineProps<T>, generic over the items' data; a bare boolean attribute is true, a reactive value reaches the instance as the plain object), every instance event as an emit (TIMELINE_EVENTS of the element), ready with the instance.
  • registerPlugin and hasPlugin (and the TimelinePlugin type) are handed on from @temporeum/timeline-element, so an app that installs only the adapter registers the plugins it needs; the element is a ^1.0.0 dependency.
  • The view and the selection are defaults — defaultDomain and defaultSelectedIds — and stay where the reader moved them on a re-render; the instance's zoomTo and select move them. Every other field is compared by what it says: an option object written anew on each render is no change, and a drag in progress goes on.
  • Server-rendered by Vue's own renderer (Nuxt included) and hydrated without a second drawing.
  • Options that need a plugin of the element (gantt, resources, the time tools, groups, the item kinds, strings, calendar, direction) need it registered once for the page, with registerPlugin from @temporeum/timeline-element — in the app's entry, before the first timeline, and where the server renders too. Without it the configuration throws, naming the import.
  • The #item slot: each item's content as Vue, teleported into the box over the item — it keeps its state while the item is drawn, and is unmounted when it leaves the view. Needs the element's /items plugin, registered once.

@temporeum/timeline-svelte

1.0.2 — 2026-11-09

On 1.0.2 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • An era's name is in the axis band, where the items cannot cover it, not at the top of the lane area under the first row's items.
  • Down a vertical timeline, a point's label starts past its dot, not under it.

1.0.1 — 2026-11-09

On 1.0.1 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • The keyboard's focus ring on a point is a circle round its dot, on a Gantt milestone a diamond round its diamond.
  • A vertical timeline's lane headers sit at the top of their column, not over its first items.

1.0.0 — 2026-11-07

The first release, on 1.0.0 of @temporeum/timeline-element. From here on the package follows semantic versioning.

  • <Timeline> (Svelte 5, runes) and timelineState: every TimelineConfig field as a prop, every instance event as an on… prop (TIMELINE_EVENTS of the element), bind:timeline for the instance.
  • The item snippet: each item's content as Svelte, rendered into the box over the item while it is drawn. Needs the element's /items plugin, registered once.
  • registerPlugin and hasPlugin (and the TimelinePlugin type) are handed on from @temporeum/timeline-element, so an app that installs only the adapter registers the plugins it needs; the element is a ^1.0.0 dependency.
  • The view and the selection are defaults — defaultDomain and defaultSelectedIds — and stay where the reader moved them on a re-render; the instance's zoomTo and select move them. Every other field is compared by what it says: an option object written anew on each render is no change, and a drag in progress goes on.
  • Server-rendered by Svelte's own renderer (SvelteKit included) and hydrated without a second drawing.
  • id, role, title, data-* and aria-* go on the box, as with the React and Vue components; aria-label names the timeline (ariaLabel), as on the element. A DOM event handler (onclick, lower case after on) is the box's too; onItemMoved and the other instance events are the timeline's.
  • Ships Timeline.d.svelte.ts too, for moduleResolution: node16 and nodenext.
  • Options that need a plugin of the element (gantt, resources, the time tools, groups, the item kinds, strings, calendar, direction) need it registered once for the page, with registerPlugin from @temporeum/timeline-element — in the app's entry, before the first timeline, and where the server renders too. Without it the configuration throws, naming the import.

@temporeum/timeline-angular

1.0.2 — 2026-11-09

On 1.0.2 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • An era's name is in the axis band, where the items cannot cover it, not at the top of the lane area under the first row's items.
  • Down a vertical timeline, a point's label starts past its dot, not under it.

1.0.1 — 2026-11-09

On 1.0.1 of @temporeum/timeline-element; no change of the component's own.

Fixed

  • The keyboard's focus ring on a point is a circle round its dot, on a Gantt milestone a diamond round its diamond.
  • A vertical timeline's lane headers sit at the top of their column, not over its first items.

1.0.0 — 2026-11-07

The first release, on 1.0.0 of @temporeum/timeline-element. From here on the package follows semantic versioning.

  • With zone.js, the instance runs outside Angular's zone (no change detection per pointer move or frame, and rolling does not keep the application from being stable); a listened-to output is emitted in the zone.
  • <ng-template tlItem let-item> (TimelineItemDirective): each item's content as an Angular template, rendered into the box over the item while it is drawn — a template that comes later, behind an @if, or goes, is followed; the slotsChanged output. Needs the element's /items plugin, registered once.
  • <tl-timeline> (standalone, OnPush, zoneless) and timelineState: the whole TimelineConfig as [config], every instance event as an output (TIMELINE_EVENTS of the element), (ready) for the instance.
  • registerPlugin and hasPlugin (and the TimelinePlugin type) are handed on from @temporeum/timeline-element, so an app that installs only the adapter registers the plugins it needs; the element is a ^1.0.0 dependency.
  • The view and the selection are defaults — defaultDomain and defaultSelectedIds — and stay where the reader moved them on a re-render; the instance's zoomTo and select move them. Every other field is compared by what it says: an option object written anew on each render is no change, and a drag in progress goes on.
  • Server-rendered with @angular/ssr and hydrated with provideClientHydration() without a second drawing.
  • Partially compiled (ngc, Angular Package Format), for Angular 21 and 22 (>=21.0.0 <23.0.0). Its peers are @angular/core and @angular/common alone — no rxjs.
  • Options that need a plugin of the element (gantt, resources, the time tools, groups, the item kinds, strings, calendar, direction) need it registered once for the page, with registerPlugin from @temporeum/timeline-element — in the app's entry, before the first timeline, and where the server renders too. Without it the configuration throws, naming the import.