@slotted/angular 0.0.0-stage → 0.1.0-beta.0

package/types/slotted-angular-timeline.d.ts

@@ -0,0 +1,329 @@
+import * as _slotted_core_timeline from '@slotted/core/timeline';
+import { TimelinePlacement, TimelineOrder, TimelineGrowing, TimelineTimeFormat, TimestampValue, TimelineConnector, TimelineSide } from '@slotted/core/timeline';
+export { TimelineConnector, TimelineGrowing, TimelineOrder, TimelinePlacement, TimelineSide, TimelineTimeFormat, TimestampValue } from '@slotted/core/timeline';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, TimelineMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+type TimelineMode = 'list' | 'feed';
+type TimelineOrientation = 'vertical' | 'horizontal';
+type TimelineVariant = 'solid' | 'outline' | 'subtle' | 'plain';
+type TimelineTone = 'secondary' | 'accent' | 'success' | 'warning' | 'danger';
+type TimelineSize = 'sm' | 'md' | 'lg';
+type TimelineLevel = 2 | 3 | 4 | 5 | 6;
+type TimelineOpenReason = 'pointer' | 'keyboard' | 'programmatic';
+type TimelineLoadMoreReason = 'pointer' | 'keyboard' | 'scroll';
+type TimelineRevealReason = 'pointer' | 'keyboard';
+
+declare const TIMELINE_DEFAULT_MODE: TimelineMode;
+declare const TIMELINE_DEFAULT_ORIENTATION: TimelineOrientation;
+declare const TIMELINE_DEFAULT_PLACEMENT: TimelinePlacement;
+declare const TIMELINE_DEFAULT_ORDER: TimelineOrder;
+declare const TIMELINE_DEFAULT_VARIANT: TimelineVariant;
+declare const TIMELINE_DEFAULT_TONE: TimelineTone;
+declare const TIMELINE_DEFAULT_SIZE: TimelineSize;
+declare const TIMELINE_DEFAULT_GROWING: TimelineGrowing;
+declare const TIMELINE_DEFAULT_TIME_FORMAT: TimelineTimeFormat;
+declare const TIMELINE_DEFAULT_LEVEL: TimelineLevel;
+interface TimelineDefaults {
+    mode?: TimelineMode;
+    orientation?: TimelineOrientation;
+    placement?: TimelinePlacement;
+    order?: TimelineOrder;
+    variant?: TimelineVariant;
+    tone?: TimelineTone;
+    size?: TimelineSize;
+    growing?: TimelineGrowing;
+    timeFormat?: TimelineTimeFormat;
+    timeZone?: string;
+    /** The moment relative readings count from, in epoch milliseconds. */
+    now?: number;
+    level?: TimelineLevel;
+}
+declare const TIMELINE_DEFAULTS_TOKEN: InjectionToken<TimelineDefaults>;
+/**
+ * An application decides once which way its timelines run, which side the
+ * events take, how a timestamp is written and in which zone, the moment a
+ * relative reading counts from. A timeline that states any of those itself
+ * still wins: an explicit input is never overridden by the token. Its words
+ * and locale come from the language in force (`provideSlotted`).
+ */
+declare function provideTimelineDefaults(defaults: TimelineDefaults): {
+    provide: InjectionToken<TimelineDefaults>;
+    useValue: TimelineDefaults;
+};
+declare function injectTimelineDefaults(): TimelineDefaults;
+
+/**
+ * An ordered list of events on one line, each with a marker, a machine
+ * timestamp and a body — and, in feed mode, the APG Feed pattern drawn the
+ * same way.
+ *
+ * **It is an `ol`, or a feed, and `mode` decides which.** The consumer writes
+ * the list element, so the mode says which one: `ol[slTimelineList]` with
+ * `li[slTimelineItem]` in list mode, `div[slTimelineList]` with
+ * `article[slTimelineItem]` in feed mode — a `li` admits no `article` role.
+ * In feed mode the list is `role="feed"`, every article carries its position,
+ * the set size and its label, the feed is busy while more is on its way, and
+ * `PageDown`, `PageUp`, `Control+End` and `Control+Home` do what the pattern
+ * says.
+ *
+ * **It never reverses the array.** `order` says what the list is, and it is
+ * what decides where `autoComplete` cuts.
+ *
+ * **It holds no events.** Loading more and revealing fresh ones are outputs
+ * with a reason and nothing to hold; the consumer owns the array. The one
+ * mutable value is whether a group is open, on `slTimelineGroup`.
+ */
+declare class SlTimeline {
+    readonly mode: _angular_core.InputSignal<TimelineMode | undefined>;
+    readonly orientation: _angular_core.InputSignal<TimelineOrientation | undefined>;
+    readonly placement: _angular_core.InputSignal<TimelinePlacement | undefined>;
+    readonly order: _angular_core.InputSignal<TimelineOrder | undefined>;
+    readonly variant: _angular_core.InputSignal<TimelineVariant | undefined>;
+    readonly tone: _angular_core.InputSignal<TimelineTone | undefined>;
+    readonly size: _angular_core.InputSignal<TimelineSize | undefined>;
+    readonly growing: _angular_core.InputSignal<TimelineGrowing | undefined>;
+    readonly timeFormat: _angular_core.InputSignal<TimelineTimeFormat | undefined>;
+    /** For the timestamps; defaults to the language in force (`provideSlotted`). */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly now: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly level: _angular_core.InputSignalWithTransform<TimelineLevel | undefined, string | number | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * more control, the waiting line, the fresh pill, the empty line, the
+     * current event's mark and a folded group's trigger.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<TimelineMessages> | undefined>;
+    /** The accessible name of the list. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** The total number of events, when the application knows it. */
+    readonly count: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly freshCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly autoComplete: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly reflow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Asked when the reader presses the more control, or scrolls to it. */
+    readonly loadMoreRequest: _angular_core.OutputEmitterRef<{
+        reason: TimelineLoadMoreReason;
+        event?: Event;
+    }>;
+    /** Asked when the reader presses the pill that holds fresh events. */
+    readonly revealRequest: _angular_core.OutputEmitterRef<{
+        reason: TimelineRevealReason;
+        event?: Event;
+    }>;
+    private readonly defaults;
+    private readonly destroyRef;
+    private readonly moreElement;
+    private readonly freshElement;
+    private readonly host;
+    private readonly injector;
+    private readonly items;
+    readonly id: string;
+    readonly modeValue: _angular_core.Signal<TimelineMode>;
+    readonly orientationValue: _angular_core.Signal<TimelineOrientation>;
+    readonly placementValue: _angular_core.Signal<TimelinePlacement>;
+    readonly orderValue: _angular_core.Signal<TimelineOrder>;
+    readonly variantValue: _angular_core.Signal<TimelineVariant>;
+    readonly toneValue: _angular_core.Signal<TimelineTone>;
+    readonly sizeValue: _angular_core.Signal<TimelineSize>;
+    readonly growingValue: _angular_core.Signal<TimelineGrowing>;
+    readonly timeFormatValue: _angular_core.Signal<TimelineTimeFormat>;
+    private readonly runtimeLocale;
+    readonly localeValue: _angular_core.Signal<string>;
+    readonly timeZoneValue: _angular_core.Signal<string | undefined>;
+    readonly nowValue: _angular_core.Signal<number | undefined>;
+    readonly levelValue: _angular_core.Signal<TimelineLevel>;
+    /** The family's words in the language in force, with this timeline's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<TimelineMessages>;
+    readonly feed: _angular_core.Signal<boolean>;
+    /**
+     * The pill's last count, kept past the change that drops it to zero: the
+     * pill stays mounted from its first appearance, hidden at zero with the
+     * words it had, so it can leave with a transition instead of vanishing.
+     */
+    readonly heldCount: _angular_core.WritableSignal<number>;
+    /** How many events the list laid out. */
+    readonly loaded: _angular_core.Signal<number>;
+    /** The index of the event marked current, in DOM order, or -1. */
+    readonly currentIndex: _angular_core.Signal<number>;
+    constructor();
+    register(items: readonly SlTimelineItem[]): void;
+    itemId(index: number, part: string): string;
+    loadMore(event: Event): void;
+    private focusRevealed;
+    reveal(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimeline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTimeline, "[slTimeline]", ["slTimeline"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "order": { "alias": "order"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "growing": { "alias": "growing"; "required": false; "isSignal": true; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "now": { "alias": "now"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "freshCount": { "alias": "freshCount"; "required": false; "isSignal": true; }; "autoComplete": { "alias": "autoComplete"; "required": false; "isSignal": true; }; "reflow": { "alias": "reflow"; "required": false; "isSignal": true; }; }, { "loadMoreRequest": "loadMoreRequest"; "revealRequest": "revealRequest"; }, never, ["*", "[slTimelineEmpty]"], true, never>;
+}
+/**
+ * The list: an `ol`, or a `div` that is a feed. It carries the name, the busy
+ * state and the feed keys, and it is the one part that sees every event, so
+ * it is what numbers them.
+ */
+declare class SlTimelineList {
+    readonly timeline: SlTimeline;
+    private readonly element;
+    private readonly ownLabel;
+    private readonly ownLabelledBy;
+    private readonly all;
+    private readonly own;
+    readonly accessibleLabel: _angular_core.Signal<string | null>;
+    constructor();
+    /** The articles a key can reach: every one not inside a folded group. */
+    articles(): HTMLElement[];
+    focusItem(index: number): void;
+    onKeydown(raw: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineList, "ol[slTimelineList], div[slTimelineList]", ["slTimelineList"], {}, {}, ["all", "own"], never, true, never>;
+}
+/**
+ * A period: a heading and its own list of events. `collapsible` makes the
+ * heading a disclosure — a `button` with `aria-expanded` and `aria-controls`
+ * — and the list takes `hidden` when it is closed rather than leaving the
+ * DOM. `open` is the family's one mutable value: `[(open)]` for the value,
+ * `(openRequest)` for the request that carries the reason and can be
+ * cancelled.
+ */
+declare class SlTimelineGroup {
+    readonly timeline: SlTimeline;
+    /** The period's name, as the heading. */
+    readonly label: _angular_core.InputSignal<string>;
+    readonly level: _angular_core.InputSignalWithTransform<TimelineLevel | undefined, string | number | undefined>;
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Present means controlled, for the life of the group. */
+    readonly open: _angular_core.ModelSignal<boolean | undefined>;
+    /** Where an uncontrolled group starts, read once. */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted before the group moves, with the request that carries the reason. */
+    readonly openRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    private readonly own;
+    readonly listId: string;
+    readonly levelValue: _angular_core.Signal<TimelineLevel>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    toggle(event: Event): void;
+    setOpen(next: boolean, reason?: TimelineOpenReason, source?: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTimelineGroup, "li[slTimelineGroup], div[slTimelineGroup]", ["slTimelineGroup"], { "label": { "alias": "label"; "required": true; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openRequest": "openRequest"; }, never, ["*"], true, never>;
+}
+/** The list inside a group: hidden while the group is folded. */
+declare class SlTimelineGroupList {
+    readonly group: SlTimelineGroup;
+    private readonly own;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineGroupList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineGroupList, "ol[slTimelineGroupList], div[slTimelineGroupList]", ["slTimelineGroupList"], {}, {}, ["own"], never, true, never>;
+}
+/**
+ * One event: its marker on the rail, the line to the next one, and its body.
+ * The body's parts are inputs for the plain case — `title`, `description`,
+ * `actor`, `time` — and projected content for the rich one, each under its
+ * own directive, so a title can be a link and an actor an avatar.
+ *
+ * In feed mode it is an `article` and a tab stop, labelled by its title, its
+ * actor and its time and described by its description, with its position in
+ * the set.
+ */
+declare class SlTimelineItem {
+    readonly timeline: SlTimeline;
+    readonly ownTabindex: string | null;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly actor: _angular_core.InputSignal<string | undefined>;
+    /** When it happened. Written to `datetime` and formatted for the reader. */
+    readonly time: _angular_core.InputSignal<TimestampValue | undefined>;
+    /** What the reader sees in place of the formatted time. */
+    readonly timeLabel: _angular_core.InputSignal<string | undefined>;
+    readonly current: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether this event is finished. Outranks the derivation. */
+    readonly complete: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The line after this event; `dashed` is derived for the future side. */
+    readonly connector: _angular_core.InputSignal<TimelineConnector | undefined>;
+    /** Which side the body takes in `alternate`; parity otherwise. */
+    readonly side: _angular_core.InputSignal<TimelineSide | undefined>;
+    readonly tone: _angular_core.InputSignal<TimelineTone | undefined>;
+    readonly variant: _angular_core.InputSignal<TimelineVariant | undefined>;
+    /** Written by the list that sees every event. */
+    readonly index: _angular_core.WritableSignal<number>;
+    /** Written by the list this event is a direct child of. */
+    readonly last: _angular_core.WritableSignal<boolean>;
+    private readonly projectedTitle;
+    private readonly projectedActor;
+    private readonly projectedDescription;
+    readonly finished: _angular_core.Signal<boolean>;
+    readonly line: _angular_core.Signal<TimelineConnector>;
+    readonly sideValue: _angular_core.Signal<TimelineSide | null>;
+    readonly setSize: _angular_core.Signal<number>;
+    readonly labelledBy: _angular_core.Signal<string | null>;
+    readonly describedBy: _angular_core.Signal<string | null>;
+    partId(part: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTimelineItem, "li[slTimelineItem], article[slTimelineItem]", ["slTimelineItem"], { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "actor": { "alias": "actor"; "required": false; "isSignal": true; }; "time": { "alias": "time"; "required": false; "isSignal": true; }; "timeLabel": { "alias": "timeLabel"; "required": false; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "complete": { "alias": "complete"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "connector": { "alias": "connector"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, ["projectedTitle", "projectedActor", "projectedDescription"], ["[slTimelineOpposite]", "[slTimelineMarker]", "[slTimelineTitle]", "[slTimelineActor]", "[slTimelineDescription]", "*", "[slTimelineActions]"], true, never>;
+}
+/**
+ * When it happened, as the platform reads it and as the reader does. The
+ * machine value always goes to `datetime`; the text is the family's
+ * formatting unless the consumer projected their own, and a relative reading
+ * keeps the absolute one in `title`. Outside a timeline it still works, from
+ * the locale in force and the runtime's zone.
+ */
+declare class SlTimelineTime {
+    private readonly timeline;
+    private readonly runtimeLocale;
+    readonly value: _angular_core.InputSignal<TimestampValue>;
+    readonly format: _angular_core.InputSignal<TimelineTimeFormat | undefined>;
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly now: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly formatted: _angular_core.Signal<_slotted_core_timeline.FormattedTimestamp>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineTime, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTimelineTime, "time[slTimelineTime]", ["slTimelineTime"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "now": { "alias": "now"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * The body's parts as the consumer's own elements: a title that is a link, an
+ * actor that is an avatar beside a name, a description with markup, a row of
+ * buttons, content for the other side of the rail, artwork for the marker.
+ * Each directive writes the part and the id the article is labelled by.
+ */
+declare class SlTimelineTitle {
+    readonly item: SlTimelineItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineTitle, "[slTimelineTitle]", never, {}, {}, never, never, true, never>;
+}
+declare class SlTimelineActor {
+    readonly item: SlTimelineItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineActor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineActor, "[slTimelineActor]", never, {}, {}, never, never, true, never>;
+}
+declare class SlTimelineDescription {
+    readonly item: SlTimelineItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineDescription, "[slTimelineDescription]", never, {}, {}, never, never, true, never>;
+}
+declare class SlTimelineActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineActions, "[slTimelineActions]", never, {}, {}, never, never, true, never>;
+}
+declare class SlTimelineOpposite {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineOpposite, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineOpposite, "[slTimelineOpposite]", never, {}, {}, never, never, true, never>;
+}
+/** Artwork projected into the marker; the marker itself is the family's. */
+declare class SlTimelineMarker {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineMarker, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineMarker, "[slTimelineMarker]", never, {}, {}, never, never, true, never>;
+}
+/** What stands in for the list while it has no events. */
+declare class SlTimelineEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTimelineEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTimelineEmpty, "[slTimelineEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+export { SlTimeline, SlTimelineActions, SlTimelineActor, SlTimelineDescription, SlTimelineEmpty, SlTimelineGroup, SlTimelineGroupList, SlTimelineItem, SlTimelineList, SlTimelineMarker, SlTimelineOpposite, SlTimelineTime, SlTimelineTitle, TIMELINE_DEFAULTS_TOKEN, TIMELINE_DEFAULT_GROWING, TIMELINE_DEFAULT_LEVEL, TIMELINE_DEFAULT_MODE, TIMELINE_DEFAULT_ORDER, TIMELINE_DEFAULT_ORIENTATION, TIMELINE_DEFAULT_PLACEMENT, TIMELINE_DEFAULT_SIZE, TIMELINE_DEFAULT_TIME_FORMAT, TIMELINE_DEFAULT_TONE, TIMELINE_DEFAULT_VARIANT, injectTimelineDefaults, provideTimelineDefaults };
+export type { TimelineDefaults, TimelineLevel, TimelineLoadMoreReason, TimelineMode, TimelineOpenReason, TimelineOrientation, TimelineRevealReason, TimelineSize, TimelineTone, TimelineVariant };
+//# sourceMappingURL=slotted-angular-timeline.d.ts.map

package/types/slotted-angular-timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-timeline.d.ts","sources":["../../timeline/src/timeline.constants.ts","../../timeline/src/timeline.ts"],"mappings":"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","names":[]}