@fusion.dev/helix-core 0.223.1 → 0.225.0

package/dist/controllers/reorder-controller/reorder-controller.js

@@ -15,9 +15,8 @@ export const requestReorder = (host, detail) => {
     if (asked.defaultPrevented) {
         return false;
     }
-    const told = new HelixReorderEvent({ ...detail, keys: [...detail.keys] });
-    host.dispatchEvent(told);
-    return !told.defaultPrevented;
+    host.dispatchEvent(new HelixReorderEvent({ ...detail, keys: [...detail.keys] }));
+    return true;
 };
 export class ReorderController {
     constructor(host, options) {

package/dist/events/before-activate.d.ts

@@ -11,12 +11,14 @@ import type { ChangeDetail } from './details.js';
  * **This fires before the state moves.** Inside a handler `currentTarget.active`
  * still holds the previous value, and `detail.value` is a proposal another
  * listener may refuse, so a consumer who only wants to know which child is
- * current listens for `helix-activate` instead. `helix-select` is not that
+ * current listens for `helix-activate` instead. `helix-before-select` is not that
  * notification either: it fires when an item is *chosen*, not when `active` is
  * assigned.
  *
  * The shape is the one `MixinControllerOpen` already has, a cancelable request
  * and a plain notification after the state has moved.
+ *
+ * @followedBy helix-activate
  */
 export declare class HelixBeforeActivateEvent extends CustomEvent<ChangeDetail> {
     static readonly eventName = "helix-before-activate";

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

@@ -19,6 +19,8 @@ import type { ChangeDetail } from './details.js';
  * **`announcesInput` picks which native notification fires, not which name this
  * carries.** Granularity is the platform's own distinction, `input` against
  * `change`; the request is always this one event.
+ *
+ * @followedBy input change
  */
 export declare class HelixBeforeChangeEvent extends CustomEvent<ChangeDetail> {
     static readonly eventName = "helix-before-change";

package/dist/events/before-check.d.ts

@@ -0,0 +1,31 @@
+import type { CheckDetail } from './details.js';
+/**
+ * A checked state is about to change, and the change can be refused.
+ *
+ * **Its own event rather than a `helix-before-change` carrying a boolean.**
+ * Through the value event the state arrives as `String(checked)`, so a consumer
+ * receives the string `"false"`, which is truthy, and a test asserting the value
+ * passes on that bug. A control whose state is a boolean wants an event with a
+ * typed boolean in it.
+ *
+ * **Named for checking, because `toggle` is open and closed.** The platform's
+ * `toggle` says a popover or a `<details>` opened or closed, and Helix relays
+ * it for its overlays, so a checked state takes a verb of its own.
+ *
+ * The notification on a form control is native, as it is for a value: the
+ * control relays `change` from the inner input and announces `input` beside
+ * it, so `onChange` reads `currentTarget.checked` and gets a boolean from the
+ * platform. A checked state that is not a form control's, such as a map layer
+ * or a code block's wrapping, sends `helix-check` once it has moved.
+ *
+ * It also ends a collision: Checkbox Group listened for its boxes' change and
+ * dispatched its own under the same name from the same host, so it needed
+ * `stopImmediatePropagation` to keep a consumer from receiving one box's boolean
+ * alongside the whole set. Two names, two facts.
+ *
+ * @followedBy change helix-check
+ */
+export declare class HelixBeforeCheckEvent extends CustomEvent<CheckDetail> {
+    static readonly eventName = "helix-before-check";
+    constructor(detail: CheckDetail);
+}

package/dist/events/before-check.js

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

package/dist/events/before-close.d.ts

@@ -1,5 +1,9 @@
 import type { OpenDetail } from './details.js';
-/** Fired when an element is about to close. See `HelixBeforeOpenEvent`. */
+/**
+ * Fired when an element is about to close. See `HelixBeforeOpenEvent`.
+ *
+ * @followedBy toggle close
+ */
 export declare class HelixBeforeCloseEvent extends CustomEvent<OpenDetail> {
     static readonly eventName = "helix-before-close";
     constructor();

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

@@ -0,0 +1,17 @@
+import type { FilterDetail } from './details.js';
+/**
+ * A component is about to narrow what it is showing, and the narrowing can be
+ * refused.
+ *
+ * Filtering hides rather than removes, so nothing about the value changes and
+ * `helix-before-change` would be a lie. What a consumer wants to know is that
+ * the list in front of the reader is about to stop being the whole list.
+ * Cancelable: refusing it leaves the list as it was, so a page can filter on a
+ * server instead.
+ *
+ * @followedBy helix-filter
+ */
+export declare class HelixBeforeFilterEvent extends CustomEvent<FilterDetail> {
+    static readonly eventName = "helix-before-filter";
+    constructor(detail: FilterDetail);
+}

package/dist/events/before-filter.js

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

package/dist/events/before-listen.d.ts

@@ -1,4 +1,8 @@
-/** A field is about to start listening for dictation, and can be refused. */
+/**
+ * A field is about to start listening for dictation, and can be refused.
+ *
+ * @followedBy helix-listen
+ */
 export declare class HelixBeforeListenEvent extends Event {
     static readonly eventName = "helix-before-listen";
     constructor();

package/dist/events/before-navigate.d.ts

@@ -0,0 +1,16 @@
+import type { NavigateDetail } from './details.js';
+/**
+ * A component is about to move the view it is showing, and the move can be
+ * refused.
+ *
+ * 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-before-change` belongs to the value,
+ * and giving it both jobs would make either one unusable on its own. Cancelable: refusing it keeps the view where it is.
+ *
+ * @followedBy helix-navigate
+ */
+export declare class HelixBeforeNavigateEvent extends CustomEvent<NavigateDetail> {
+    static readonly eventName = "helix-before-navigate";
+    constructor(detail: NavigateDetail);
+}

package/dist/events/before-navigate.js

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

package/dist/events/before-open.d.ts

@@ -10,6 +10,8 @@ import type { OpenDetail } from './details.js';
  * Neither bubbles nor composed. A dialog inside a drawer inside a popover is
  * three overlays, and an inner one opening must not read as the outer one
  * opening.
+ *
+ * @followedBy toggle
  */
 export declare class HelixBeforeOpenEvent extends CustomEvent<OpenDetail> {
     static readonly eventName = "helix-before-open";

package/dist/events/before-pin.d.ts

@@ -1,5 +1,9 @@
 import type { ChangeDetail } from './details.js';
-/** A message is about to be pinned or unpinned, and can be refused. */
+/**
+ * A message is about to be pinned or unpinned, and can be refused.
+ *
+ * @followedBy helix-pin
+ */
 export declare class HelixBeforePinEvent extends CustomEvent<ChangeDetail> {
     static readonly eventName = "helix-before-pin";
     constructor(detail: ChangeDetail);

package/dist/events/before-reorder.d.ts

@@ -7,6 +7,8 @@ import type { ReorderDetail } from './details.js';
  * the move would leave. Call `preventDefault()` to keep the item where it is: a
  * pinned row, or a place the item may not go. Nothing has moved yet, and
  * `helix-reorder` follows where nobody refused.
+ *
+ * @followedBy helix-reorder
  */
 export declare class HelixBeforeReorderEvent extends CustomEvent<ReorderDetail> {
     static readonly eventName = "helix-before-reorder";

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

@@ -1,5 +1,9 @@
 import type { ChangeDetail } from './details.js';
-/** A divider is about to move, and can be refused. */
+/**
+ * A divider is about to move, and can be refused.
+ *
+ * @followedBy helix-resized
+ */
 export declare class HelixBeforeResizeEvent extends CustomEvent<ChangeDetail> {
     static readonly eventName = "helix-before-resize";
     constructor(detail: ChangeDetail);

package/dist/events/before-select.d.ts

@@ -0,0 +1,19 @@
+import type { SelectDetail } from './details.js';
+/**
+ * The reader chose an item in a set, and the choice can be refused.
+ *
+ * Bubbles and is composed, because this is how a set coordinates: a tree, a
+ * tab list and a toggle group all learn which of their children was chosen by
+ * hearing it arrive. Cancelable: refusing it leaves the set as it was.
+ *
+ * **What follows is the set's own notification.** A set that holds a
+ * selection, such as Data Table or Log, sends `helix-select` once it has
+ * moved. A set that makes the chosen child current sends `helix-activate`, and
+ * a set holding a value sends `change`.
+ *
+ * @followedBy helix-select helix-activate change
+ */
+export declare class HelixBeforeSelectEvent extends CustomEvent<SelectDetail> {
+    static readonly eventName = "helix-before-select";
+    constructor(detail: SelectDetail);
+}

package/dist/events/before-select.js

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

package/dist/events/before-sort.d.ts

@@ -0,0 +1,19 @@
+import type { SortDetail } from './details.js';
+/**
+ * The reader asked for a different order, and the order can be refused.
+ *
+ * Cancelable, and refusing it leaves the order alone, which is what makes a
+ * server-side sort expressible: the consumer refuses the local reorder, fetches,
+ * and hands back a new set. This is the element reporting that a heading was
+ * clicked, before it acts on it.
+ *
+ * Not `helix-before-change`: nothing about the data changed, only the order it
+ * is read in, and a consumer listening for changes to a value should not hear a
+ * sort. That is the same distinction `helix-before-filter` is drawn on.
+ *
+ * @followedBy helix-sort
+ */
+export declare class HelixBeforeSortEvent extends CustomEvent<SortDetail> {
+    static readonly eventName = "helix-before-sort";
+    constructor(detail: SortDetail);
+}

package/dist/events/before-sort.js

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

package/dist/events/check.d.ts

@@ -0,0 +1,15 @@
+import type { CheckDetail } from './details.js';
+/**
+ * A checked state changed after `helix-before-check` let it: a map layer shown
+ * or hidden from the layers menu, or a code block's lines wrapped. Sent from
+ * what changed, with the state it now holds.
+ *
+ * **For a checked state that is not a form control's.** A form control sends
+ * the native `change` instead, which `onChange` already reads. The native
+ * `toggle` is a `ToggleEvent` saying a popover or a `<details>` opened or
+ * closed, and a layer shown on a map is neither.
+ */
+export declare class HelixCheckEvent extends CustomEvent<CheckDetail> {
+    static readonly eventName = "helix-check";
+    constructor(detail: CheckDetail);
+}

package/dist/events/{caret.js → check.js}

@@ -1,7 +1,7 @@
-export class HelixCaretEvent extends CustomEvent {
-    static { this.eventName = 'helix-caret'; }
+export class HelixCheckEvent extends CustomEvent {
+    static { this.eventName = 'helix-check'; }
     constructor(detail) {
-        super(HelixCaretEvent.eventName, {
+        super(HelixCheckEvent.eventName, {
             bubbles: true,
             cancelable: false,
             composed: true,