ar-timeline-view 0.0.0-stage → 1.0.2

package/dist/types/api.d.ts

@@ -0,0 +1,16 @@
+import type { Id, MovePatchData, MoveResultData, TimelineViewData } from "./types";
+/** A non-2xx response. `body` is the parsed JSON body, if there was one. */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown);
+}
+/** Client for the REST API described in CLAUDE.md and docs/api/openapi.yaml. */
+export declare class RestClient {
+    private readonly fetchImpl;
+    private readonly baseUrl;
+    constructor(baseUrl: string, fetchImpl?: typeof fetch);
+    getView(viewId: Id): Promise<TimelineViewData>;
+    moveEntry(viewId: Id, timelineId: Id, taskId: Id, patch: MovePatchData, version: number | undefined): Promise<MoveResultData>;
+    private request;
+}

package/dist/types/dates.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dates are handled in UTC throughout, so day and month arithmetic is not
+ * affected by daylight saving time in the viewer's zone.
+ */
+export declare function parseDate(text: string): Date;
+/** Formats as `YYYY-MM-DD`, adding `THH:mm` when the time is not midnight. */
+export declare function formatDate(date: Date): string;
+export declare function daysInMonth(year: number, month: number): number;
+/** Adds calendar months, clamping the day to the end of the target month. */
+export declare function addMonths(date: Date, months: number): Date;
+export declare function addDays(date: Date, days: number): Date;

package/dist/types/drag.d.ts

@@ -0,0 +1,47 @@
+import type { Offset } from "./types";
+export type DropTarget = {
+    timeline: string;
+    placement: "on";
+    line: number;
+    newLine: boolean;
+} | {
+    timeline: string;
+    placement: "above" | "below";
+};
+/** A finished drag. IDs are the DOM's string form; the view maps them back. */
+export interface DropEvent {
+    timeline: string;
+    task: string;
+    target: DropTarget;
+    /** Set when the target is a callout area. */
+    offset?: Offset;
+}
+/** A marker label dropped somewhere: its new `marker_offset`. The id is the DOM's string form. */
+export interface MarkerDropEvent {
+    marker: string;
+    offset: Offset;
+}
+interface Rect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+}
+/**
+ * Callout offset for a label dropped at `box` in the callout area `area`.
+ * `at` is the attachment point as a fraction of the area's width. The
+ * attachment point is on the bar's edge: the area's bottom above the bar, its
+ * top below it. `y` is clamped so the label stays on its own side of the bar.
+ */
+export declare function calloutOffset(box: Rect, area: Rect, at: number, placement: "above" | "below"): Offset;
+/**
+ * Makes every `[data-entry]` inside `root` draggable. A press and release
+ * without moving past the drag threshold is a click instead, reported to
+ * `onClick` with the entry's element; a drag never reports a click.
+ * The same kind of click elsewhere in a timeline or on the view's heading
+ * (not on an entry) goes to `onBackgroundClick`, with the pressed element.
+ * Returns a function that detaches.
+ */
+export declare function attachDrag(root: HTMLElement, onDrop: (event: DropEvent) => void, onClick?: (entry: HTMLElement, event: PointerEvent) => void, onBackgroundClick?: (target: HTMLElement, event: PointerEvent) => void, onMarkerDrop?: (event: MarkerDropEvent) => void): () => void;
+export {};

package/dist/types/duration.d.ts

@@ -0,0 +1,11 @@
+export type DurationUnit = "h" | "d" | "w" | "m" | "y";
+export interface Duration {
+    amount: number;
+    unit: DurationUnit;
+}
+/** Parses `"2d"`, `"3m"` and so on. `m` is months; there is no minutes unit. */
+export declare function parseDuration(text: string): Duration;
+/** Adds a duration. Months and years are calendar units, clamped to the month's end. */
+export declare function addDuration(start: Date, { amount, unit }: Duration): Date;
+/** A task is a milestone when its duration is missing or zero. */
+export declare function isMilestoneDuration(text: string | undefined): boolean;

package/dist/types/index.d.ts

@@ -0,0 +1,28 @@
+import "./styles.css";
+import type { Id, MovePatchData, Offset, TimelineViewData } from "./types";
+import { TimelineView, type TimelineEventName, type TimelineEvents, type TimelineHandlers, type TimelineOptions } from "./view";
+export * from "./types";
+export { ApiError, RestClient } from "./api";
+export { MoveError, TimelineModel, firstLine, lineCount, patchFromData, trimLines, timelineToData } from "./model";
+export { parseDuration, addDuration } from "./duration";
+export { MoveCancelledError, TimelineView, type EntryMovedEvent, type MarkerMovedEvent, type MoveFailedEvent, type TimelineEvents, type TimelineEventName, type TimelineHandlers, type TimelineOptions, } from "./view";
+export declare function init(container: string | HTMLElement, options?: TimelineOptions): TimelineView;
+export declare const parse: (data: TimelineViewData) => void;
+export declare const load: (viewId: Id) => Promise<void>;
+export declare const serialize: () => TimelineViewData;
+export declare const toSVG: () => string;
+export declare const moveEntry: (timelineId: Id, taskId: Id, patch: MovePatchData) => Promise<void>;
+export declare const attachEvent: <K extends TimelineEventName>(name: K, handler: TimelineHandlers[K]) => number;
+export declare const detachEvent: (eventId: number) => boolean;
+export declare const selectTask: (id: Id, add?: boolean) => boolean;
+export declare const selectTimeline: (id: Id, add?: boolean) => boolean;
+export declare const unselectTask: (id: Id) => boolean;
+export declare const unselectTimeline: (id: Id) => boolean;
+export declare const clearSelection: () => void;
+export declare const getSelectedTasks: () => Id[];
+export declare const getSelectedTimelines: () => Id[];
+export declare const setMarkerOffset: (markerId: Id, offset: Offset) => void;
+export declare const moveTimelineUp: (id: Id) => boolean;
+export declare const moveTimelineDown: (id: Id) => boolean;
+export declare const moveTimeline: (id: Id, delta: number) => boolean;
+export declare const on: <K extends keyof TimelineEvents>(name: K, handler: (event: TimelineEvents[K]) => void) => () => void;

package/dist/types/model.d.ts

@@ -0,0 +1,127 @@
+import type { Id, MilestoneSymbol, MovePatchData, NamePosition, Offset, Placement, Scale, TimelineData, TimelineViewData } from "./types";
+export interface View {
+    id?: Id;
+    name: string;
+    absolute: boolean;
+    scale: Scale;
+    namePosition: NamePosition;
+    milestoneSymbol: MilestoneSymbol;
+    showDates: boolean;
+    /** Whether clicks select tasks and timelines. */
+    selection: boolean;
+}
+export interface Task {
+    id: Id;
+    text: string;
+    start: Date;
+    /** `start + duration`; equal to `start` for milestones. */
+    finish: Date;
+    duration?: string;
+    isMilestone: boolean;
+    symbol?: MilestoneSymbol;
+    /** CSS color overriding the theme's task or milestone color. */
+    color?: string;
+}
+export interface Marker {
+    id: Id;
+    text: string;
+    date: Date;
+    global: boolean;
+    color?: string;
+    /** Label position; `y ≤ 0` above the topmost bar, `y > 0` below the bottommost. */
+    offset: Offset;
+}
+export type Entry = {
+    taskId: Id;
+    placement: "on";
+    line: number;
+} | {
+    taskId: Id;
+    placement: "above" | "below";
+    calloutOffset: Offset;
+};
+export interface Timeline {
+    id: Id;
+    name: string;
+    start: Date;
+    finish: Date;
+    entries: Entry[];
+    /** Ids of the (non-global) markers shown on this timeline. */
+    markers: Id[];
+}
+export interface MovePatch {
+    timelineId?: Id;
+    placement?: Placement;
+    line?: number;
+    newLine?: boolean;
+    calloutOffset?: Offset;
+}
+/** Mirrors the REST status codes, so a local move fails the same way a server move would. */
+export type MoveErrorCode = "not_found" | "conflict" | "invalid";
+export declare class MoveError extends Error {
+    readonly code: MoveErrorCode;
+    constructor(code: MoveErrorCode, message: string);
+}
+/** Default distance, in px, between the bar and a callout label without an offset. */
+export declare const DEFAULT_CALLOUT_GAP = 16;
+export declare const defaultOffset: (placement: "above" | "below") => Offset;
+export declare class TimelineModel {
+    view: View;
+    tasks: Task[];
+    timelines: Timeline[];
+    markers: Marker[];
+    version?: number;
+    private constructor();
+    static fromData(data: TimelineViewData): TimelineModel;
+    toData(): TimelineViewData;
+    /** Converts and validates one timeline. */
+    timelineFromData(t: TimelineData): Timeline;
+    private entryFromData;
+    findTask(id: Id): Task | undefined;
+    /** Moves a marker's label. `y ≤ 0` puts it above the topmost bar, `y > 0` below the bottommost. */
+    setMarkerOffset(id: Id, offset: Offset): Marker;
+    findMarker(id: Id): Marker | undefined;
+    findTimeline(id: Id): Timeline | undefined;
+    findEntry(timelineId: Id, taskId: Id): Entry | undefined;
+    /**
+     * Moves an entry to another bar line, callout position, area or timeline.
+     * `newLine` inserts a new bar line at `line`, shifting the lines from there
+     * down; a `line` one past the last also opens one. Afterwards the affected
+     * timelines are trimmed (see `trimLines`): a line an entry leaves stays as
+     * an empty gap only between used lines.
+     *
+     * Returns the timelines the move changed (source first).
+     */
+    moveEntry(timelineId: Id, taskId: Id, patch: MovePatch): Timeline[];
+    /**
+     * Moves a timeline `delta` places in the stack: -1 is up, 1 is down.
+     * Returns false, changing nothing, if it would move past the top or bottom.
+     */
+    moveTimeline(id: Id, delta: number): boolean;
+    /** Replaces whole timelines, as returned by a successful REST move. */
+    replaceTimelines(data: TimelineData[]): void;
+}
+/**
+ * The time axis the view draws on: from the earliest timeline start to the
+ * latest finish. With `absolute`, every bar is placed on this axis.
+ */
+export declare function viewRange(model: TimelineModel): {
+    start: Date;
+    finish: Date;
+} | undefined;
+/** The lowest `line` the bar entries use; 0 when there are none. */
+export declare function firstLine(timeline: Timeline): number;
+/**
+ * Removes blank bar lines above the first used one by renumbering the
+ * entries so the first used line is 0. Blank lines below the last used one
+ * need no trimming: `lineCount` doesn't count them. Gaps between used lines stay.
+ */
+export declare function trimLines(timeline: Timeline): void;
+/**
+ * Number of bar lines, counted from line 0: one more than the highest `line`
+ * the entries use, at least 1. It is never stored.
+ */
+export declare function lineCount(timeline: Timeline): number;
+export declare function timelineToData(t: Timeline): TimelineData;
+/** Converts a public move body to the internal form. */
+export declare function patchFromData(p: MovePatchData): MovePatch;

package/dist/types/render.d.ts

@@ -0,0 +1,25 @@
+import { type TimelineModel } from "./model";
+/** Bar line height in px. The drag code reads positions from the DOM, so only rendering uses this. */
+export declare const BAR_LINE_HEIGHT = 28;
+/**
+ * How far, in px, each callout's edge marker sticks out from the bar. The
+ * connector starts there: at the marker's outer edge, in its middle.
+ * Keep in step with .tlv-edge-bar and .tlv-edge-symbol in styles.css.
+ */
+export declare const EDGE_BAR_HEIGHT = 6;
+export declare const EDGE_SYMBOL_REACH = 8;
+/** Replaces the contents of `root` with the rendered view. */
+export declare function render(root: HTMLElement, model: TimelineModel): void;
+/**
+ * Places each marker line: horizontally at its date on the first timeline's
+ * span, vertically from that timeline's bar top (or row top) to the last
+ * one's bar bottom (or row bottom). Being one element, it is drawn with
+ * the same width everywhere.
+ *
+ * Positions are measured in the viewport and converted using where a line
+ * placed at 0,0 actually lands, so borders and scrolling of the view (and
+ * how the browser treats them) don't matter.
+ */
+export declare function layoutMarkerLines(root: HTMLElement): void;
+/** Stops watching the view's layout (when the view is destroyed). */
+export declare function unwatchLayout(root: HTMLElement): void;

package/dist/types/scale.d.ts

@@ -0,0 +1,23 @@
+import type { Scale } from "./types";
+export interface Tick {
+    date: Date;
+    /** Position in the timeline's time span, 0 to 1. */
+    at: number;
+    label: string;
+    /**
+     * Running number of the period that starts at this tick, counted from a
+     * fixed date. Its parity shades periods alternately, the same way on every
+     * timeline whatever its start date.
+     */
+    serial: number;
+}
+/** Upper bound so a fine scale on a long span cannot create a huge DOM. */
+export declare const MAX_TICKS = 1000;
+/** Position of a date in the span, 0 at `start` and 1 at `finish`. Not clamped. */
+export declare function fraction(date: Date, start: Date, finish: Date): number;
+/** ISO 8601 week number. */
+export declare function isoWeek(date: Date): number;
+/** Running number of the scale period that holds `date`. */
+export declare function periodSerial(date: Date, scale: Scale): number;
+/** Tick marks for the time scale, from the first boundary at or after `start` up to `finish`. */
+export declare function ticks(start: Date, finish: Date, scale: Scale): Tick[];

package/dist/types/svg.d.ts

@@ -0,0 +1,8 @@
+/**
+ * SVG export. Rather than describing the layout a second time, this reads the
+ * rendered view: element boxes, measured text and computed colors. The result
+ * is plain SVG (rects, paths, lines, text) that matches what is on screen,
+ * including theming and dark mode. The view must be rendered and visible.
+ */
+/** Builds an SVG document of the view rendered in `root`. */
+export declare function toSVG(root: HTMLElement): string;

package/dist/types/types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Public data format: what `parse()` accepts, what `serialize()` returns and
+ * what the REST API exchanges. Uses snake_case (see CLAUDE.md, Conventions).
+ */
+export type Id = string | number;
+export type Placement = "above" | "on" | "below";
+export type Scale = "hour" | "day" | "week" | "month" | "year";
+export type MilestoneSymbol = "diamond" | "circle" | "square" | "triangle" | "star";
+export type NamePosition = "left" | "right";
+/**
+ * Callout label position, in px, relative to the attachment point on the
+ * bar's edge: the middle of a task's span, or a milestone's date. `x` is to
+ * the label's left edge. `y` is to the label's edge nearest the bar, and
+ * also picks the side: `y > 0` is below the bar, `y ≤ 0` above it.
+ */
+export interface Offset {
+    /** Px from the attachment point to the label's left edge. */
+    x: number;
+    y: number;
+}
+export interface ViewData {
+    /** Needed when a REST backend is configured. */
+    id?: Id;
+    /** Shown as a heading above the timelines. Empty for no heading. */
+    name: string;
+    /**
+     * `false` (default): each timeline's bar fills the full width, scaled to its
+     * own dates. `true`: all timelines share one time axis, from the earliest
+     * start to the latest finish, and each bar is drawn at its offset and width
+     * on it, so the same date lines up across timelines.
+     */
+    absolute?: boolean;
+    /** Unit of the time scale. Default: `day`. */
+    scale?: Scale;
+    /** Side of each timeline the name label is shown on. Default: `left`. */
+    name_position?: NamePosition;
+    /** Symbol used for milestones. Default: `diamond`. */
+    milestone_symbol?: MilestoneSymbol;
+    /** Show each timeline's start and finish dates, with "Start" and "Finish" captions, beside its bar. Default: `true`. */
+    show_dates?: boolean;
+    /**
+     * Clicking a task or timeline selects and highlights it, and fires
+     * `onTaskSelected` / `onTimelineSelected`. Default: `true`.
+     */
+    selection?: boolean;
+}
+/** A task's finish date is not stored: it is `start_date + duration`. */
+export interface TaskData {
+    id: Id;
+    text: string;
+    start_date: string;
+    /** A whole number plus `h`, `d`, `w`, `m` or `y`. Missing or zero means milestone. */
+    duration?: string;
+    /** Overrides the view's `milestone_symbol` for this task. */
+    symbol?: MilestoneSymbol;
+    /**
+     * Any CSS color, such as `"#0a7f5a"` or `"rebeccapurple"`. Overrides the
+     * theme's `--tlv-task` (bars) or `--tlv-milestone` (symbols) for this task,
+     * on the bar and on its callout's edge marker.
+     */
+    color?: string;
+}
+/**
+ * Where a task appears on a timeline. The area follows from the fields:
+ * - no `callout_offset`: on the bar, on bar `line` (default 0);
+ * - `callout_offset` with `y > 0`: a callout below the bar;
+ * - `callout_offset` with `y ≤ 0`: a callout above the bar.
+ */
+export interface TaskEntryData {
+    task: Id;
+    /** 0-based bar line, for an entry on the bar. Default: 0. Not allowed with `callout_offset`. */
+    line?: number;
+    /** Makes the entry a callout, and places its label (see `Offset`). */
+    callout_offset?: Offset;
+}
+/** Shows a (non-global) marker on this timeline. */
+export interface MarkerEntryData {
+    marker: Id;
+}
+/** An entry is a task on the timeline, or a marker shown on it. */
+export type EntryData = TaskEntryData | MarkerEntryData;
+/**
+ * A date marker: a vertical line at `date` across the bars of the timelines
+ * that show it, with a label at its top or bottom end.
+ */
+export interface MarkerData {
+    id: Id;
+    text: string;
+    /** ISO 8601: `YYYY-MM-DD` or `YYYY-MM-DDTHH:mm`. */
+    date: string;
+    /** `true`: shown on every timeline. `false` (default): only on timelines with a `{ marker: id }` entry. */
+    global?: boolean;
+    /** Any CSS color. Default: the theme's `--tlv-marker` (red). */
+    color?: string;
+    /**
+     * Places the label, like `callout_offset`: px from the line's end on the
+     * bar's edge to the label. `y ≤ 0`: above the topmost bar; `y > 0`: below
+     * the bottommost. Default: `{ x: 0, y: -16 }`.
+     */
+    marker_offset?: Offset;
+}
+export interface TimelineData {
+    id: Id;
+    name: string;
+    /** The timeline's time range. ISO 8601: `YYYY-MM-DD` or `YYYY-MM-DDTHH:mm`. */
+    start_date: string;
+    finish_date: string;
+    entries: EntryData[];
+}
+export interface TimelineViewData {
+    /** Server version, used for optimistic concurrency with the REST API. */
+    version?: number;
+    view: ViewData;
+    tasks: TaskData[];
+    timelines: TimelineData[];
+    /** Date markers. Optional. */
+    markers?: MarkerData[];
+}
+/** Body of `PATCH .../entries/{task_id}`, minus `version`. Send only what changes. */
+export interface MovePatchData {
+    timeline_id?: Id;
+    placement?: Placement;
+    line?: number;
+    /** With placement `on`: insert a new bar line at `line` (0 to one past the last line); lines from there down shift by one. */
+    new_line?: boolean;
+    callout_offset?: Offset;
+}
+/** Response of a successful move. */
+export interface MoveResultData {
+    version: number;
+    timelines: TimelineData[];
+}

package/dist/types/view.d.ts

@@ -0,0 +1,173 @@
+import type { Id, MovePatchData, Offset, TimelineViewData } from "./types";
+export interface TimelineOptions {
+    /** Base URL of the REST backend. Without it, changes are only reported through events. */
+    api_url?: string;
+    /** Replacement for `fetch`, mainly for tests and mock backends. */
+    fetch?: typeof fetch;
+}
+export interface EntryMovedEvent {
+    timeline_id: Id;
+    task_id: Id;
+    patch: MovePatchData;
+}
+export interface MoveFailedEvent extends EntryMovedEvent {
+    error: unknown;
+}
+export interface MarkerMovedEvent {
+    marker_id: Id;
+    marker_offset: Offset;
+}
+export interface TimelineEvents {
+    /** A move was applied on screen. Fired before the REST request, if any, is sent. */
+    entry_moved: EntryMovedEvent;
+    /** A move was rejected, locally or by the server. The view shows the restored state. */
+    move_failed: MoveFailedEvent;
+    /**
+     * A marker's label was moved (dragged, or `setMarkerOffset`). Markers have
+     * no REST call yet, so saving the new `marker_offset` is up to the host.
+     */
+    marker_moved: MarkerMovedEvent;
+}
+type Handler<T> = (event: T) => void;
+/**
+ * Handlers for `attachEvent`. Inside a handler written as a `function`, `this`
+ * is the TimelineView, with the same methods as the global `timeline`.
+ */
+export interface TimelineHandlers {
+    /**
+     * A task bar, milestone or callout label was clicked (pressed and released
+     * without dragging). `id` is the task's id; `timelineId` the timeline it was
+     * clicked on, since a task can appear on several.
+     */
+    onTaskClick: (this: TimelineView, id: Id, e: MouseEvent, timelineId: Id) => void;
+    /**
+     * A timeline was clicked outside its tasks: its name, bar background, time
+     * scale, dates or callout areas.
+     */
+    onTimelineClick: (this: TimelineView, id: Id, e: MouseEvent) => void;
+    /** The selected tasks changed; `ids` are all selected tasks now, empty when none are. */
+    onTaskSelected: (this: TimelineView, ids: Id[]) => void;
+    /** The selected timelines changed; `ids` are all selected timelines now, empty when none are. */
+    onTimelineSelected: (this: TimelineView, ids: Id[]) => void;
+}
+export type TimelineEventName = keyof TimelineHandlers;
+/** Thrown for moves queued behind one that failed; their changes were rolled back with it. */
+export declare class MoveCancelledError extends Error {
+    constructor();
+}
+export declare class TimelineView {
+    readonly container: HTMLElement;
+    private model?;
+    private readonly api?;
+    private readonly listeners;
+    /** `attachEvent` handlers by event id. */
+    private readonly handlers;
+    private lastEventId;
+    /**
+     * Selection: tasks or timelines, never both at once. A selected task is
+     * highlighted wherever it appears.
+     */
+    private selected;
+    private readonly detachDrag;
+    /** REST requests run one at a time, in the order the moves were made. */
+    private queue;
+    private pending;
+    /** Bumped whenever local state is reset after a failure; queued requests from before are dropped. */
+    private generation;
+    constructor(container: string | HTMLElement, options?: TimelineOptions);
+    /** Loads data in the public format and renders it. */
+    parse(data: TimelineViewData): void;
+    /** Fetches a view from the REST backend and renders it. */
+    load(viewId: Id): Promise<void>;
+    /**
+     * The view as a standalone SVG document, as it looks on screen now. The
+     * view must be rendered in the page and visible, since the export reads
+     * its layout.
+     */
+    toSVG(): string;
+    /** The current data, in the same format `parse()` takes. */
+    serialize(): TimelineViewData;
+    on<K extends keyof TimelineEvents>(name: K, handler: Handler<TimelineEvents[K]>): () => void;
+    /**
+     * Subscribes to an event, such as `onTaskClick`. Returns an event id for
+     * `detachEvent`. Inside a `function` handler, `this` is this view.
+     */
+    attachEvent<K extends TimelineEventName>(name: K, handler: TimelineHandlers[K]): number;
+    /** Removes a handler added with `attachEvent`. Returns false if the id is unknown. */
+    detachEvent(eventId: number): boolean;
+    /** The selected tasks' ids, in the order they were selected; empty when timelines (or nothing) are selected. */
+    getSelectedTasks(): Id[];
+    /** The selected timelines' ids, in the order they were selected; empty when tasks (or nothing) are selected. */
+    getSelectedTimelines(): Id[];
+    /**
+     * Selects a task, highlighted wherever it appears. With `add`, it joins the
+     * tasks already selected (as Ctrl+Click does); otherwise it replaces the
+     * selection. Selecting a task always deselects timelines. Fires the selected
+     * events for what changed. Returns false when selection is turned off
+     * (`view.selection: false`).
+     */
+    selectTask(id: Id, add?: boolean): boolean;
+    /** Like `selectTask`, for a timeline. Selecting a timeline always deselects tasks. */
+    selectTimeline(id: Id, add?: boolean): boolean;
+    /** Deselects one task. Returns false if it wasn't selected. */
+    unselectTask(id: Id): boolean;
+    /** Deselects one timeline. Returns false if it wasn't selected. */
+    unselectTimeline(id: Id): boolean;
+    /** Deselects everything. */
+    clearSelection(): void;
+    /**
+     * Moves a marker's label, as dragging it does: `y ≤ 0` above the topmost
+     * bar showing the marker, `y > 0` below the bottommost. Fires `marker_moved`.
+     */
+    setMarkerOffset(markerId: Id, offset: Offset): void;
+    /** Moves a timeline one place up the stack. Returns false if it is already at the top. */
+    moveTimelineUp(id: Id): boolean;
+    /** Moves a timeline one place down the stack. Returns false if it is already at the bottom. */
+    moveTimelineDown(id: Id): boolean;
+    /**
+     * Moves a timeline `delta` places: negative is up, positive down. Returns
+     * false, changing nothing, past the top or bottom. The new order shows in
+     * `serialize()`; the REST API has no call for it yet.
+     */
+    moveTimeline(id: Id, delta: number): boolean;
+    /**
+     * Moves an entry: shows the move at once, fires `entry_moved` and, with a
+     * REST backend, sends the PATCH. Rolls back and fires `move_failed` if the
+     * move is invalid or the server rejects it.
+     */
+    moveEntry(timelineId: Id, taskId: Id, patch: MovePatchData): Promise<void>;
+    /** Removes the view's DOM and event listeners. */
+    destroy(): void;
+    private rollback;
+    private onDrop;
+    /** Calls every `attachEvent` handler for `name`, with this view as `this`. */
+    private callHandlers;
+    private onMarkerDrop;
+    private onEntryClick;
+    /** A click on a timeline outside its tasks, or on the view's heading. */
+    private onBackgroundClick;
+    /**
+     * Selection by clicking. Click: select only this item, or, if it is
+     * already selected, clear the selection. Ctrl+Click (Cmd+Click on a Mac):
+     * add or remove this item; on the other kind of item it starts a new
+     * selection with just this one.
+     */
+    private clickSelect;
+    private isSelected;
+    private select;
+    private unselect;
+    /**
+     * Sets the selection and updates the highlight. Fires `onTaskSelected`
+     * and/or `onTimelineSelected` for each kind whose selection changed (the
+     * kind being left reports an empty list).
+     */
+    private setSelection;
+    /** After new data: forgets selected tasks or timelines that are gone, or everything if selection is off. */
+    private dropStaleSelection;
+    /** Marks the selected tasks' elements, or the selected timelines, in the DOM. */
+    private applySelection;
+    private emit;
+    private requireModel;
+    private render;
+}
+export {};

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "ar-timeline-view",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.2",
+  "description": "A web-based timeline component for displaying and editing timelines.",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/timelineview.js",
+  "module": "./dist/timelineview.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/timelineview.mjs",
+      "default": "./dist/timelineview.js"
+    },
+    "./timelineview.css": "./dist/timelineview.css"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && tsc -p tsconfig.build.json && node scripts/export-examples.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "jsdom": "^31.0.0",
+    "puppeteer": "^25.16.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.6",
+    "vitest": "^5.1.0"
+  }
+}