@fusion.dev/helix-core 0.144.0 → 0.146.0

package/dist/events/expand.d.ts

@@ -0,0 +1,10 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * Rows opened or closed in place: a data table's tree of rows. Carries every
+ * open row's key, separated by commas, which the table's `expanded` also
+ * holds. Not cancelable: the rows have already moved.
+ */
+export declare class HelixExpandEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-expand";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/expand.js

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

package/dist/events/facet.d.ts

@@ -0,0 +1,17 @@
+import type { FacetDetail } from './details.js';
+/**
+ * Fired when the reader changes which values a field is filtered by.
+ *
+ * **Not `helix-filter`, which is a different thing already taken.** That one
+ * says a list narrowed itself to a string, and `Data Table` and `Listbox` both
+ * dispatch it with exactly that meaning. This one carries a structured filter:
+ * a field, a comparison and a set of values, which is a shape neither of those
+ * has and neither should grow.
+ *
+ * Cancelable, and refusing it is how a consumer takes the decision for one
+ * interaction, the way `requestChange` documents for every stateful change here.
+ */
+export declare class HelixFacetEvent extends CustomEvent<FacetDetail> {
+    static readonly eventName = "helix-facet";
+    constructor(detail: FacetDetail);
+}

package/dist/events/facet.js

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

package/dist/events/filter.d.ts

@@ -0,0 +1,12 @@
+import type { FilterDetail } from './details.js';
+/**
+ * Fired when a component narrows what it is showing.
+ *
+ * Filtering hides rather than removes, so nothing about the value changes and
+ * `helix-change` would be a lie. What a consumer wants to know is that the list
+ * in front of the reader is no longer the whole list.
+ */
+export declare class HelixFilterEvent extends CustomEvent<FilterDetail> {
+    static readonly eventName = "helix-filter";
+    constructor(detail: FilterDetail);
+}

package/dist/events/filter.js

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

package/dist/events/filtered.d.ts

@@ -0,0 +1,12 @@
+import type { FilterDetail } from './details.js';
+/**
+ * A component is showing a narrower or a wider set.
+ *
+ * The notification after `helix-filter`, sent once the query has moved, with
+ * the query now in force. Not cancelable, and past tense for the reason
+ * `helix-sorted` is.
+ */
+export declare class HelixFilteredEvent extends CustomEvent<FilterDetail> {
+    static readonly eventName = "helix-filtered";
+    constructor(detail: FilterDetail);
+}

package/dist/events/filtered.js

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

package/dist/events/graph-filter.d.ts

@@ -0,0 +1,10 @@
+import type { GraphFilterDetail } from './details.js';
+/**
+ * A reader pressed a group in the graph's legend, which would show or hide
+ * its notes, sent from the frame before it does. Cancelable: cancel it to
+ * keep the groups as they were, or to set `hiddenGroups` yourself.
+ */
+export declare class HelixGraphFilterEvent extends CustomEvent<GraphFilterDetail> {
+    static readonly eventName = "helix-graph-filter";
+    constructor(detail: GraphFilterDetail);
+}

package/dist/events/graph-filter.js

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

package/dist/events/graph-layout.d.ts

@@ -0,0 +1,10 @@
+import type { GraphLayoutDetail } from './details.js';
+/**
+ * A layout settled, with where it put every note. Keep the positions and hand
+ * them back as each note's `x` and `y`, and the graph opens where the reader
+ * left it, with no layout to run.
+ */
+export declare class HelixGraphLayoutEvent extends CustomEvent<GraphLayoutDetail> {
+    static readonly eventName = "helix-graph-layout";
+    constructor(detail: GraphLayoutDetail);
+}

package/dist/events/graph-layout.js

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

package/dist/events/graph-pan.d.ts

@@ -0,0 +1,9 @@
+import type { ViewportPanDetail } from './details.js';
+/**
+ * The reader asked the graph to move. A request, as a map's is: Helix draws no
+ * graph, and the renderer the page slotted, or `connectGraph`, answers it.
+ */
+export declare class HelixGraphPanEvent extends CustomEvent<ViewportPanDetail> {
+    static readonly eventName = "helix-graph-pan";
+    constructor(detail: ViewportPanDetail);
+}

package/dist/events/graph-pan.js

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

package/dist/events/graph-part-change.d.ts

@@ -0,0 +1,10 @@
+import type { GraphPartChangeDetail } from './details.js';
+/**
+ * The frame's notes, links, selection, depth or gestures changed, which the
+ * connector hears and the renderer is told. It stays on the frame, being the
+ * family's own bookkeeping rather than news for a page.
+ */
+export declare class HelixGraphPartChangeEvent extends CustomEvent<GraphPartChangeDetail> {
+    static readonly eventName = "helix-graph-part-change";
+    constructor(detail: GraphPartChangeDetail);
+}

package/dist/events/graph-part-change.js

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

package/dist/events/graph-ready.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The graph has been drawn whole, laid out and settled, sent once each time it
+ * is connected, from the frame, which then matches `:state(ready)`.
+ */
+export declare class HelixGraphReadyEvent extends Event {
+    static readonly eventName = "helix-graph-ready";
+    constructor();
+}

package/dist/events/graph-ready.js

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

package/dist/events/graph-signal.d.ts

@@ -0,0 +1,11 @@
+import type { GraphSignalDetail } from './details.js';
+/**
+ * Something passed between two notes, which the renderer draws traveling
+ * from one to the other. The connector hears it and the renderer draws it; it
+ * stays on the frame, being the family's own bookkeeping rather than news for
+ * a page.
+ */
+export declare class HelixGraphSignalEvent extends CustomEvent<GraphSignalDetail> {
+    static readonly eventName = "helix-graph-signal";
+    constructor(detail: GraphSignalDetail);
+}

package/dist/events/graph-signal.js

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

package/dist/events/graph-zoom.d.ts

@@ -0,0 +1,6 @@
+import type { ViewportZoomDetail } from './details.js';
+/** The reader asked the graph to zoom, a direction and not a level, as a map's is. */
+export declare class HelixGraphZoomEvent extends CustomEvent<ViewportZoomDetail> {
+    static readonly eventName = "helix-graph-zoom";
+    constructor(detail: ViewportZoomDetail);
+}

package/dist/events/graph-zoom.js

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

package/dist/events/history.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fired when a reader reaches the oldest turn a transcript holds, while there are
+ * older ones to fetch.
+ *
+ * **A report of where the reader is, not a request to be granted**, so it is not
+ * cancelable: there is nothing for the transcript to do if nobody refuses, and
+ * nothing to stop if somebody does. The consumer answers by fetching, and says
+ * so through the transcript's `history` while the older turns are on their way.
+ *
+ * No detail. The consumer holds the transcript and knows its oldest turn, which
+ * is the one thing a fetch needs.
+ */
+export declare class HelixHistoryEvent extends CustomEvent<Record<string, never>> {
+    static readonly eventName = "helix-history";
+    constructor();
+}

package/dist/events/history.js

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

package/dist/events/load-more.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A reader asked for more items: a feed's or a table's `load-more` button, or
+ * a list scrolled near its end. Append them, and set `loading` while they are
+ * on their way.
+ *
+ * Carries nothing, because what comes next is the consumer's to know. Not
+ * cancelable: nothing is loaded until the consumer loads it.
+ */
+export declare class HelixLoadMoreEvent extends Event {
+    static readonly eventName = "helix-load-more";
+    constructor();
+}

package/dist/events/load-more.js

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

package/dist/events/load.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A lazy branch opened and asks for its children: a tree item with `lazy`.
+ * Sent from the item, so `target` is the branch to fill.
+ *
+ * Carries nothing, because the children are the consumer's to fetch. Not
+ * cancelable: the branch is already open, and says it is busy until children
+ * arrive.
+ */
+export declare class HelixLoadEvent extends Event {
+    static readonly eventName = "helix-load";
+    constructor();
+}

package/dist/events/load.js

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

package/dist/events/map-cluster.d.ts

@@ -0,0 +1,15 @@
+import type { MapClusterDetail } from './details.js';
+/**
+ * A reader pressed a cluster, one marker standing for several that would have
+ * drawn over each other.
+ *
+ * **Opened by zooming in**, which the connector does, framing the places the
+ * cluster holds, as pressing one does on every map a reader has used. Told
+ * rather than asked: a page that lists them in a panel instead connects with
+ * `clusterZoom: false`. Sent from the marker the cluster is drawn as, and
+ * bubbles through the frame to the page.
+ */
+export declare class HelixMapClusterEvent extends CustomEvent<MapClusterDetail> {
+    static readonly eventName = "helix-map-cluster";
+    constructor(detail: MapClusterDetail);
+}

package/dist/events/map-cluster.js

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

package/dist/events/map-pan.d.ts

@@ -0,0 +1,18 @@
+import type { MapPanDetail, ViewportPanDetail } from './details.js';
+/**
+ * The reader asked the map to move, which is as far as this library goes.
+ *
+ * **Helix draws no map and moves nobody's.** A tile renderer is a library and
+ * the frame around it is what this adds, so panning is a request the consumer
+ * answers against whatever they slotted: MapLibre, Leaflet, Google, or their
+ * own. The direction is in reading order rather than compass order, because the
+ * control that sent it is a button a reader pressed and `start` on a
+ * right-to-left page is east.
+ *
+ * Not cancelable. Nothing here moves on its own, and an event whose
+ * `preventDefault` means nothing is an event that lies about what it offers.
+ */
+export declare class HelixMapPanEvent extends CustomEvent<ViewportPanDetail> {
+    static readonly eventName = "helix-map-pan";
+    constructor(detail: MapPanDetail);
+}

package/dist/events/map-pan.js

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

package/dist/events/map-part-change.d.ts

@@ -0,0 +1,16 @@
+import type { MapPartChangeDetail } from './details.js';
+/**
+ * A marker, a position, a route or an area changed what it says: where it is,
+ * its points, its progress, its name.
+ *
+ * **Said rather than reflected.** The connector and the frame follow the
+ * parts, and heard them through their attributes until the parts reflected
+ * nothing CSS selects on: a live position's coordinates are state, and a
+ * route's points are a payload, neither of which belongs in the markup. It
+ * bubbles to the frame, whose light-DOM children the parts are, and goes no
+ * further, being the family's own bookkeeping rather than news for a page.
+ */
+export declare class HelixMapPartChangeEvent extends CustomEvent<MapPartChangeDetail> {
+    static readonly eventName = "helix-map-part-change";
+    constructor(detail: MapPartChangeDetail);
+}

package/dist/events/map-part-change.js

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

package/dist/events/map-ready.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The map has been drawn whole: its style, every tile the view needs, and the
+ * ground raised where it has terrain. Sent once each time a map is connected,
+ * from the frame, which then matches `:state(ready)`.
+ *
+ * **What a page waits on to show a map that is finished**, where it would
+ * otherwise watch it draw in stages: the streets, then the imagery tile by
+ * tile, then the ground rising under the markers about half a second in. The
+ * shapes the frame draws are left out of "whole", since a route that animates
+ * is redrawn every frame and would never count as drawn.
+ */
+export declare class HelixMapReadyEvent extends Event {
+    static readonly eventName = "helix-map-ready";
+    constructor();
+}

package/dist/events/map-ready.js

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

package/dist/events/map-rotate.d.ts

@@ -0,0 +1,9 @@
+import type { MapRotateDetail } from './details.js';
+/**
+ * The user asked the map to rotate, from a rotate button or key. Turn your map
+ * in response. Not cancelable, because the frame moves nothing itself.
+ */
+export declare class HelixMapRotateEvent extends CustomEvent<MapRotateDetail> {
+    static readonly eventName = "helix-map-rotate";
+    constructor(detail: MapRotateDetail);
+}

package/dist/events/map-rotate.js

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

package/dist/events/map-tilt.d.ts

@@ -0,0 +1,9 @@
+import type { MapTiltDetail } from './details.js';
+/**
+ * The user asked the map to tilt, from a tilt button or key. Tilt your map in
+ * response. Not cancelable, because the frame moves nothing itself.
+ */
+export declare class HelixMapTiltEvent extends CustomEvent<MapTiltDetail> {
+    static readonly eventName = "helix-map-tilt";
+    constructor(detail: MapTiltDetail);
+}

package/dist/events/map-tilt.js

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

package/dist/events/map-zoom.d.ts

@@ -0,0 +1,13 @@
+import type { MapZoomDetail, ViewportZoomDetail } from './details.js';
+/**
+ * The reader asked the map to zoom, and for the same reason it is a request.
+ *
+ * `by` is a direction rather than a level: a scale a consumer's map understands
+ * is the consumer's to decide, and a frame that said "go to zoom 14" would be
+ * asserting a numbering that Leaflet, MapLibre and a static tile server do not
+ * agree on.
+ */
+export declare class HelixMapZoomEvent extends CustomEvent<ViewportZoomDetail> {
+    static readonly eventName = "helix-map-zoom";
+    constructor(detail: MapZoomDetail);
+}

package/dist/events/map-zoom.js

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

package/dist/events/move.d.ts

@@ -0,0 +1,11 @@
+import type { MoveDetail } from './details.js';
+/**
+ * Cards moved, and the move is finished: a drag let go, or a key press.
+ *
+ * The `change` to `helix-before-move`'s `input`: what a consumer binds who
+ * only wants to save a board once somebody has finished rearranging it.
+ */
+export declare class HelixMoveEvent extends CustomEvent<MoveDetail> {
+    static readonly eventName = "helix-move";
+    constructor(detail: MoveDetail);
+}

package/dist/events/move.js

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

package/dist/events/names.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Every name this library dispatches.
+ *
+ * Exported so a runtime check can ask whether a name is one of ours without
+ * keeping a second list of them. `HelixElement` uses it to tell a consumer that
+ * the handler prop they wrote is attached to nothing.
+ *
+ * **Written as strings, in a module of its own, and not read off the
+ * classes in `registry`.** Every element carries this set through its React
+ * prop audit, and a set read off the classes kept every class alive in every
+ * bundle: a Badge shipped all eighty of them. As strings, a family ships the
+ * classes it dispatches and no others. `events.pure.spec.ts` holds this list to
+ * the classes, so a class added without its name here fails.
+ */
+export declare const helixEventNames: ReadonlySet<string>;