@fusion.dev/helix-core 0.145.0 → 0.146.0

package/dist/events/names.js

@@ -0,0 +1,88 @@
+export const helixEventNames = new Set([
+    'helix-action',
+    'helix-activate',
+    'helix-aura-fallback',
+    'helix-before-activate',
+    'helix-before-change',
+    'helix-before-close',
+    'helix-before-collapse',
+    'helix-before-edit',
+    'helix-before-move',
+    'helix-before-open',
+    'helix-before-panel-resize',
+    'helix-before-pin',
+    'helix-before-reconnect',
+    'helix-before-relabel',
+    'helix-before-resize',
+    'helix-before-split',
+    'helix-before-toggle',
+    'helix-canvas-edit',
+    'helix-canvas-pan',
+    'helix-canvas-view',
+    'helix-canvas-zoom',
+    'helix-caret',
+    'helix-clear',
+    'helix-collapse',
+    'helix-complete',
+    'helix-connect',
+    'helix-console',
+    'helix-copy',
+    'helix-copy-error',
+    'helix-create',
+    'helix-dismiss',
+    'helix-edit',
+    'helix-end',
+    'helix-expand',
+    'helix-facet',
+    'helix-filter',
+    'helix-filtered',
+    'helix-graph-filter',
+    'helix-graph-layout',
+    'helix-graph-pan',
+    'helix-graph-part-change',
+    'helix-graph-ready',
+    'helix-graph-signal',
+    'helix-graph-zoom',
+    'helix-history',
+    'helix-load',
+    'helix-load-more',
+    'helix-map-cluster',
+    'helix-map-pan',
+    'helix-map-part-change',
+    'helix-map-ready',
+    'helix-map-rotate',
+    'helix-map-tilt',
+    'helix-map-zoom',
+    'helix-move',
+    'helix-navigate',
+    'helix-next',
+    'helix-panel-resize',
+    'helix-pin',
+    'helix-press',
+    'helix-preview',
+    'helix-previous',
+    'helix-range-change',
+    'helix-read',
+    'helix-reconnect',
+    'helix-reject',
+    'helix-relabel',
+    'helix-remove',
+    'helix-reorder',
+    'helix-reordered',
+    'helix-resize',
+    'helix-resized',
+    'helix-sample-end',
+    'helix-sample-start',
+    'helix-scrolled',
+    'helix-select',
+    'helix-selected',
+    'helix-send',
+    'helix-shortcut',
+    'helix-sort',
+    'helix-sorted',
+    'helix-split',
+    'helix-toggle',
+    'helix-tour-ask',
+    'helix-tour-status',
+    'helix-typing',
+]);

package/dist/events/navigate.d.ts

@@ -0,0 +1,13 @@
+import type { NavigateDetail } from './details.js';
+/**
+ * Fired when a component moves the view it is showing, rather than its value.
+ *
+ * A calendar paging to another month is not choosing a date, and the two have
+ * to be separable: a consumer driving the view needs to hear that it moved
+ * without being told the answer changed. `helix-change` belongs to the value,
+ * and giving it both jobs would make either one unusable on its own.
+ */
+export declare class HelixNavigateEvent extends CustomEvent<NavigateDetail> {
+    static readonly eventName = "helix-navigate";
+    constructor(detail: NavigateDetail);
+}

package/dist/events/navigate.js

@@ -0,0 +1,11 @@
+export class HelixNavigateEvent extends CustomEvent {
+    static { this.eventName = 'helix-navigate'; }
+    constructor(detail) {
+        super(HelixNavigateEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/next.d.ts

@@ -0,0 +1,23 @@
+import type { SkipDetail } from './details.js';
+/**
+ * Fired when the reader asks for the next thing in a set.
+ *
+ * Paired with `helix-previous` rather than being one event carrying a
+ * direction, which is the reason `helix-before-open` gives for its own pair: a
+ * listener that only cares about one direction says so by which event it
+ * listens for. The detail carries the direction anyway, so a consumer who does
+ * want one handler can have one.
+ *
+ * Bubbles and is composed, because the thing that answers this is usually not
+ * the thing that asked. A video has no notion of a set: it plays one resource,
+ * and what comes next is a playlist's business or the consumer's, so the event
+ * has to reach a wrapper.
+ *
+ * Not cancelable. There is no default action to refuse: the component that
+ * fires this does nothing on its own, and an event whose `preventDefault` means
+ * nothing is an event that lies about what it offers.
+ */
+export declare class HelixNextEvent extends CustomEvent<SkipDetail> {
+    static readonly eventName = "helix-next";
+    constructor();
+}

package/dist/events/next.js

@@ -0,0 +1,11 @@
+export class HelixNextEvent extends CustomEvent {
+    static { this.eventName = 'helix-next'; }
+    constructor() {
+        super(HelixNextEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail: { to: 'next' },
+        });
+    }
+}

package/dist/events/panel-resize.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A sandbox's panel settled at a new height.
+ *
+ * The notification half of `helix-before-panel-resize`, sent once `panelSize`
+ * has moved, with the height in pixels. Not cancelable: the decision was the
+ * request's.
+ */
+export declare class HelixPanelResizeEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-panel-resize";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/panel-resize.js

@@ -0,0 +1,11 @@
+export class HelixPanelResizeEvent extends CustomEvent {
+    static { this.eventName = 'helix-panel-resize'; }
+    constructor(detail) {
+        super(HelixPanelResizeEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/pin.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A transcript was pinned to the bottom, or let go of it.
+ *
+ * The notification half of `helix-before-pin`, sent once `pinned` has moved,
+ * so `currentTarget.pinned` is the new state and `detail.value` says it as
+ * `true` or `false`. Not cancelable: the decision was the request's.
+ */
+export declare class HelixPinEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-pin";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/pin.js

@@ -0,0 +1,11 @@
+export class HelixPinEvent extends CustomEvent {
+    static { this.eventName = 'helix-pin'; }
+    constructor(detail) {
+        super(HelixPinEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/press.d.ts

@@ -0,0 +1,19 @@
+import type { PressDetail } from './details.js';
+/**
+ * A control was pressed and acted, whatever pressed it: a pointer, Enter or
+ * Space, or a screen reader. React Aria's `onPress`.
+ *
+ * **One event for every way in, with the way in on it.** `click` arrives for
+ * all of them and says which only in some engines: Chromium sends a keyboard
+ * press and a script's `click()` alike, with no pointer kind and a count of
+ * zero. `pointerType` here is worked out once, by `pressType`, for every
+ * listener.
+ *
+ * Sent after the press has acted, and only when it has: a disabled or pending
+ * control sends none. Not cancelable, since the action is done. Bubbles and is
+ * composed, as `click` does.
+ */
+export declare class HelixPressEvent extends CustomEvent<PressDetail> {
+    static readonly eventName = "helix-press";
+    constructor(detail: PressDetail);
+}

package/dist/events/press.js

@@ -0,0 +1,11 @@
+export class HelixPressEvent extends CustomEvent {
+    static { this.eventName = 'helix-press'; }
+    constructor(detail) {
+        super(HelixPressEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/preview.d.ts

@@ -0,0 +1,14 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A control is showing what a press would choose, before anything is chosen:
+ * a rating lighting the marks under the pointer. Zag's `onHoverChange`.
+ *
+ * `value` is the value being previewed, and `''` once the preview ends and
+ * the control shows its own value again. Sent each time the preview changes,
+ * not on every pointer move. Not cancelable, since a preview changes nothing.
+ * Bubbles and is composed.
+ */
+export declare class HelixPreviewEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-preview";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/preview.js

@@ -0,0 +1,11 @@
+export class HelixPreviewEvent extends CustomEvent {
+    static { this.eventName = 'helix-preview'; }
+    constructor(detail) {
+        super(HelixPreviewEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/previous.d.ts

@@ -0,0 +1,6 @@
+import type { SkipDetail } from './details.js';
+/** Fired when the reader asks for the previous one. See `HelixNextEvent`. */
+export declare class HelixPreviousEvent extends CustomEvent<SkipDetail> {
+    static readonly eventName = "helix-previous";
+    constructor();
+}

package/dist/events/previous.js

@@ -0,0 +1,11 @@
+export class HelixPreviousEvent extends CustomEvent {
+    static { this.eventName = 'helix-previous'; }
+    constructor() {
+        super(HelixPreviousEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail: { to: 'previous' },
+        });
+    }
+}

package/dist/events/range-change.d.ts

@@ -0,0 +1,10 @@
+import type { RangeDetail } from './details.js';
+/**
+ * The items on screen changed: a virtual list was scrolled or resized, or its
+ * items changed. Carries the new range, which the list's `range` also holds.
+ * Not cancelable: the list has already moved.
+ */
+export declare class HelixRangeChangeEvent extends CustomEvent<RangeDetail> {
+    static readonly eventName = "helix-range-change";
+    constructor(detail: RangeDetail);
+}

package/dist/events/range-change.js

@@ -0,0 +1,11 @@
+export class HelixRangeChangeEvent extends CustomEvent {
+    static { this.eventName = 'helix-range-change'; }
+    constructor(detail) {
+        super(HelixRangeChangeEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/read.d.ts

@@ -0,0 +1,19 @@
+import type { ReadDetail } from './details.js';
+/**
+ * Fired when something a user comes back to is marked read, or unread.
+ *
+ * **Read state is reported rather than owned.** Marking a notification read is
+ * usually a round trip, and a component that flips the state itself and then
+ * hears the request failed has already told the reader something untrue. So this
+ * is cancelable, and refusing it leaves the item alone; the component applies
+ * it once nobody has refused, which is the same contract every other axis in
+ * the library uses.
+ *
+ * Bubbles and is composed, so a feed hears its own items: one handler on the
+ * list serves every notification in it, which is what a consumer syncing to a
+ * server actually wants.
+ */
+export declare class HelixReadEvent extends CustomEvent<ReadDetail> {
+    static readonly eventName = "helix-read";
+    constructor(detail: ReadDetail);
+}

package/dist/events/read.js

@@ -0,0 +1,11 @@
+export class HelixReadEvent extends CustomEvent {
+    static { this.eventName = 'helix-read'; }
+    constructor(detail) {
+        super(HelixReadEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/reconnect.d.ts

@@ -0,0 +1,6 @@
+import type { ReconnectDetail } from './details.js';
+/** A connection's end moved, and the move is finished. */
+export declare class HelixReconnectEvent extends CustomEvent<ReconnectDetail> {
+    static readonly eventName = "helix-reconnect";
+    constructor(detail: ReconnectDetail);
+}

package/dist/events/reconnect.js

@@ -0,0 +1,11 @@
+export class HelixReconnectEvent extends CustomEvent {
+    static { this.eventName = 'helix-reconnect'; }
+    constructor(detail) {
+        super(HelixReconnectEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/reject.d.ts

@@ -0,0 +1,13 @@
+import type { RejectDetail } from './details.js';
+/**
+ * Files arrived at a file field and some were refused: by `accept`, by
+ * `max-file-size`, by `max-files`, or by the field's own `validate`.
+ *
+ * A notification and not a request, because the files are already left out;
+ * the event is how a page tells the reader why. Bubbles and is composed, so a
+ * form around the field hears it.
+ */
+export declare class HelixRejectEvent extends CustomEvent<RejectDetail> {
+    static readonly eventName = "helix-reject";
+    constructor(detail: RejectDetail);
+}

package/dist/events/reject.js

@@ -0,0 +1,11 @@
+export class HelixRejectEvent extends CustomEvent {
+    static { this.eventName = 'helix-reject'; }
+    constructor(detail) {
+        super(HelixRejectEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/relabel.d.ts

@@ -0,0 +1,6 @@
+import type { RelabelDetail } from './details.js';
+/** A label the board draws changed. */
+export declare class HelixRelabelEvent extends CustomEvent<RelabelDetail> {
+    static readonly eventName = "helix-relabel";
+    constructor(detail: RelabelDetail);
+}

package/dist/events/relabel.js

@@ -0,0 +1,11 @@
+export class HelixRelabelEvent extends CustomEvent {
+    static { this.eventName = 'helix-relabel'; }
+    constructor(detail) {
+        super(HelixRelabelEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/remove.d.ts

@@ -0,0 +1,12 @@
+import type { RemoveDetail } from './details.js';
+/**
+ * A reader asked for cards or connections to be taken away.
+ *
+ * A request for the reason `helix-connect` is one: the elements are the page's,
+ * so the page removes them. Nothing to refuse, because nothing happens unless
+ * the page acts.
+ */
+export declare class HelixRemoveEvent extends CustomEvent<RemoveDetail> {
+    static readonly eventName = "helix-remove";
+    constructor(detail: RemoveDetail);
+}

package/dist/events/remove.js

@@ -0,0 +1,11 @@
+export class HelixRemoveEvent extends CustomEvent {
+    static { this.eventName = 'helix-remove'; }
+    constructor(detail) {
+        super(HelixRemoveEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/reorder.d.ts

@@ -0,0 +1,18 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * Fired when the reader asks for the columns in a different order.
+ *
+ * Cancelable, and refusing it leaves the columns where they were, so a consumer
+ * who stores the order, in a URL or a preference, can take the decision the way
+ * a server-side sort takes `helix-sort`. The detail is the whole order as
+ * space-separated fields rather than one move, because the order is the fact a
+ * consumer stores, and a move is only meaningful against an order they would
+ * then have to keep in step.
+ *
+ * Not `helix-sort`: that reorders the rows, this reorders the columns, and a
+ * consumer listening for one should not hear the other.
+ */
+export declare class HelixReorderEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-reorder";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/reorder.js

@@ -0,0 +1,11 @@
+export class HelixReorderEvent extends CustomEvent {
+    static { this.eventName = 'helix-reorder'; }
+    constructor(detail) {
+        super(HelixReorderEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/reordered.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * The columns are in a different order.
+ *
+ * The notification after `helix-reorder`, sent once the order has moved, with
+ * every field in the new one. Not cancelable, and past tense for the reason
+ * `helix-sorted` is.
+ */
+export declare class HelixReorderedEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-reordered";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/reordered.js

@@ -0,0 +1,11 @@
+export class HelixReorderedEvent extends CustomEvent {
+    static { this.eventName = 'helix-reordered'; }
+    constructor(detail) {
+        super(HelixReorderedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/resize.d.ts

@@ -0,0 +1,19 @@
+import type { ResizeDetail } from './details.js';
+/**
+ * Fired when something reports how much room its content actually needs.
+ *
+ * **A measurement crossing a boundary the measurer is on the far side of.** A
+ * sandboxed preview is its own document: nothing outside it can read the height
+ * of what it drew, because the frame is opaque and a box sized from the outside
+ * only ever reports the box. So the document measures itself and says so, and
+ * this is what it says it with.
+ *
+ * A number rather than a box, because the width is the container's to decide and
+ * only the block size follows the content. A consumer that wants to act on it
+ * clamps it: what arrives is what was drawn, which for an empty example is
+ * nearly nothing and for a long one is more than a page.
+ */
+export declare class HelixResizeEvent extends CustomEvent<ResizeDetail> {
+    static readonly eventName = "helix-resize";
+    constructor(detail: ResizeDetail);
+}

package/dist/events/resize.js

@@ -0,0 +1,11 @@
+export class HelixResizeEvent extends CustomEvent {
+    static { this.eventName = 'helix-resize'; }
+    constructor(detail) {
+        super(HelixResizeEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/resized.d.ts

@@ -0,0 +1,16 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A divider settled somewhere new.
+ *
+ * The notification half of `helix-before-resize`, sent once `position` has
+ * moved, with the new position. Not cancelable: the decision was the
+ * request's.
+ *
+ * **Past tense, because `helix-resize` was already taken** by a measurement,
+ * the height a sandboxed preview reports for what it drew, and one name cannot
+ * carry both.
+ */
+export declare class HelixResizedEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-resized";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/resized.js

@@ -0,0 +1,11 @@
+export class HelixResizedEvent extends CustomEvent {
+    static { this.eventName = 'helix-resized'; }
+    constructor(detail) {
+        super(HelixResizedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/sample-end.d.ts

@@ -0,0 +1,5 @@
+/** The eyedropper closing, whether or not a color was taken. */
+export declare class HelixSampleEndEvent extends Event {
+    static readonly eventName = "helix-sample-end";
+    constructor();
+}

package/dist/events/sample-end.js

@@ -0,0 +1,6 @@
+export class HelixSampleEndEvent extends Event {
+    static { this.eventName = 'helix-sample-end'; }
+    constructor() {
+        super(HelixSampleEndEvent.eventName, { bubbles: true, cancelable: false, composed: true });
+    }
+}

package/dist/events/sample-start.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The eyedropper opening, and closing again.
+ *
+ * Two events rather than one carrying a flag, because what a consumer does with
+ * them is not symmetrical: the surface holding the picker has to get out of the
+ * way for the sample and come back afterwards, and those are two moments with
+ * different work in each.
+ *
+ * **A class rather than a bare `Event`.** The check that holds an event to being
+ * declared reads `new Event(` as well as `new HelixSomethingEvent(`, so a
+ * hand-rolled one is public API a consumer can hear and cannot find.
+ *
+ * No detail, because there is nothing to say beyond that it happened.
+ */
+export declare class HelixSampleStartEvent extends Event {
+    static readonly eventName = "helix-sample-start";
+    constructor();
+}

package/dist/events/sample-start.js

@@ -0,0 +1,6 @@
+export class HelixSampleStartEvent extends Event {
+    static { this.eventName = 'helix-sample-start'; }
+    constructor() {
+        super(HelixSampleStartEvent.eventName, { bubbles: true, cancelable: false, composed: true });
+    }
+}

package/dist/events/scrolled.d.ts

@@ -0,0 +1,32 @@
+import type { ScrolledDetail } from './details.js';
+/**
+ * Fired when a header crosses the threshold between resting at the top of the
+ * page and floating over it.
+ *
+ * **The threshold lives in a custom state, and is announced rather than
+ * reflected.** A `data-scrolled` on the host is an attribute nobody rendered: a
+ * server sends the element without it and the element adds it on upgrade, so a
+ * framework hydrating the page finds markup that no longer matches what it sent.
+ * A custom state is deliberately not in the DOM and therefore not something a
+ * hydration pass can disagree with.
+ *
+ * That closes the observability an attribute would accidentally provide. A
+ * `MutationObserver` can watch an attribute and there is no equivalent for
+ * `ElementInternals.states`, so a component holding a boolean nothing can read
+ * is a component with a private opinion its consumers demonstrably need: the
+ * bar's own backdrop is drawn by the page around it, and the page has to know
+ * when to light it.
+ *
+ * Not cancelable. It reports where the page is rather than asking permission to
+ * be there, and refusing it would leave the state and the announcement
+ * disagreeing.
+ *
+ * The hysteresis stays inside the header, which is the point of announcing at
+ * all: a consumer listening to `scroll` itself would be a second opinion on
+ * when the page counts as scrolled, and the two would part company at the eight
+ * pixels of travel this waits for.
+ */
+export declare class HelixScrolledEvent extends CustomEvent<ScrolledDetail> {
+    static readonly eventName = "helix-scrolled";
+    constructor(detail: ScrolledDetail);
+}

package/dist/events/scrolled.js

@@ -0,0 +1,11 @@
+export class HelixScrolledEvent extends CustomEvent {
+    static { this.eventName = 'helix-scrolled'; }
+    constructor(detail) {
+        super(HelixScrolledEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}