@fusion.dev/helix-core 0.145.0 → 0.147.0

package/dist/controllers/source-controller/source-controller.d.ts

@@ -107,13 +107,20 @@ export declare class SourceController implements ReactiveController {
     get hidden(): ReadonlySet<string>;
     /**
      * Hides these series on the table and shows every other, for every chart
-     * and legend reading it, which then redraw.
+     * and legend reading it, which then redraw. Answers the table it wrote to,
+     * or null where `for` names none.
+     *
+     * Given `among`, only those names are shown or hidden, and a series hidden
+     * outside them stays hidden. A legend passes its own entries, so a legend
+     * of the rows and a legend of the columns on one table each keep what the
+     * other hid.
      *
      * Names are matched without regard to case or surrounding space, as a
      * column's heading is everywhere else. Nothing happens where `for` names no
-     * table, or the set is already this one.
+     * table, or the set is already this one, so two writers that agree stop
+     * asking each other to redraw.
      */
-    hide(names: Iterable<string>): void;
+    hide(names: Iterable<string>, among?: Iterable<string>): Element | null;
     /** Counts this controller among the readers of the table it watches, or of none. */
     private enlist;
     hostConnected(): void;

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

@@ -1,3 +1,4 @@
+import { auditSource } from '#audit-source';
 import { elementById } from '../../utils/element-by-id/element-by-id.js';
 import { readRows, readSeries, seriesKey, } from '../../utils/read-series/read-series.js';
 const HIDDEN = new WeakMap();
@@ -54,15 +55,17 @@ export class SourceController {
         const element = this.element;
         return element ? (HIDDEN.get(element) ?? NONE) : NONE;
     }
-    hide(names) {
+    hide(names, among) {
         const element = this.resolve();
         if (!element) {
-            return;
+            return null;
         }
-        const next = new Set([...names].map(seriesKey).filter(Boolean));
         const now = HIDDEN.get(element) ?? NONE;
+        const mine = among === undefined ? undefined : new Set([...among].map(seriesKey));
+        const kept = mine === undefined ? [] : [...now].filter((one) => !mine.has(one));
+        const next = new Set([...kept, ...[...names].map(seriesKey)].filter(Boolean));
         if (next.size === now.size && [...next].every((one) => now.has(one))) {
-            return;
+            return element;
         }
         if (next.size === 0) {
             HIDDEN.delete(element);
@@ -73,6 +76,7 @@ export class SourceController {
         for (const reader of READERS.get(element) ?? []) {
             reader.host.requestUpdate();
         }
+        return element;
     }
     enlist(element) {
         if (this.watched) {
@@ -89,6 +93,7 @@ export class SourceController {
     }
     hostConnected() {
         this.watch();
+        auditSource(this.host, () => this.resolve());
     }
     hostUpdated() {
         if (this.deferred) {

package/dist/controllers/swipe-controller/swipe-controller.d.ts

@@ -10,6 +10,12 @@ export interface SwipeOptions {
     end: (dx: number, dy: number, vx: number, vy: number) => void;
     /** Called as the pointer moves, with how far it has gone from the press. */
     move: (dx: number, dy: number) => void;
+    /**
+     * How far a press travels before it is a swipe, in pixels: 8 where this is
+     * not given. A mouse drag that takes over sooner, such as Carousel's at 4,
+     * says so here.
+     */
+    slop?: number;
     /**
      * Whether a press may start a swipe, given the element it landed on. Every
      * press may where this is not given. A field, a scroller that has its own use
@@ -32,7 +38,10 @@ export interface SwipeOptions {
  * axis.** Before that it is still a press, so a tap on a button inside the
  * surface is a tap, and a drag across the axis, a reader scrolling, is left to
  * the page. Once it is a swipe, the click that ends it is swallowed, so a
- * swipe that started on a button does not also press it.
+ * swipe that started on a button does not also press it. The swallow is held on
+ * the window for one task after the release, so a spec that swipes and then
+ * presses a control in the same task sees that press swallowed: wait a task
+ * between them, as a reader's next press always does.
  *
  * The move and the release are heard on the window, so a pointer that leaves
  * the surface mid-swipe is still followed.

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

@@ -34,7 +34,7 @@ export class SwipeController {
             if (!this.swiping) {
                 const along = Math.abs(axis === 'x' ? dx : dy);
                 const across = Math.abs(axis === 'x' ? dy : dx);
-                if (Math.max(along, across) < SLOP) {
+                if (Math.max(along, across) < (this.options.slop ?? SLOP)) {
                     return;
                 }
                 if (across >= along) {

package/dist/controllers/virtualize-controller/virtualize-controller.d.ts

@@ -20,7 +20,9 @@ export interface VirtualizeOptions {
      * the straight line the note below defends. A host that returns its row
      * elements gets each one measured after it renders and placed by what it
      * came to; a host that returns nothing gets every item at `estimate`, which
-     * is right whenever the rows really are uniform and is cheaper.
+     * is right whenever the rows really are uniform and is cheaper. A host that
+     * returns its rows and turns `measured` off keeps the straight line, with its
+     * slope read once from the rows it drew.
      *
      * **Each row carries its own index rather than being counted off from
      * `window.first`.** A host is free to place its rows whenever it likes, and
@@ -129,6 +131,15 @@ export declare class VirtualizeController implements ReactiveController {
     private readonly heights;
     /** Room `shift` added above the window, owed to the scroll offset once drawn. */
     private owed;
+    /**
+     * The drawn rows' height on the straight line, read once per estimate.
+     *
+     * Undefined until a host that offers `rows` has drawn some on the uniform
+     * path, and again after `forget`.
+     */
+    private sample;
+    /** The length of the set when `endInSight` last answered true. */
+    private askedAt;
     constructor(host: ReactiveControllerHost, options: VirtualizeOptions);
     hostConnected(): void;
     hostDisconnected(): void;
@@ -145,6 +156,28 @@ export declare class VirtualizeController implements ReactiveController {
     measure(): void;
     /** The straight line: one estimate, so offset and index convert by division. */
     private uniform;
+    /**
+     * How tall one item is on the straight line: the drawn rows' height once
+     * read, and `estimate` until then.
+     *
+     * **An estimate that is wrong on the straight line leaves the end of the
+     * set out of reach.** Rows of 21 pixels placed at 32 fill two thirds of the
+     * room they are counted for, so the window stops short of the bottom of the
+     * box and the spacer after it holds the rest: in Chromium, `scrollToIndex`
+     * on the last of 5,000 such rows scrolled to the end and drew nothing there.
+     * Reading the drawn rows once corrects the slope, and it is still a line.
+     */
+    private line;
+    /**
+     * Reads the drawn rows' height once for the straight line, for a host that
+     * offers `rows` and does not measure.
+     *
+     * The mean of the rows drawn, each item's elements counted together. A row
+     * with no height, such as one that is not laid out, says nothing. When the
+     * line moves, the scroll offset moves with it, so the item at the top of the
+     * box stays there.
+     */
+    private sampleRows;
     /** Whether this pass places by measurement: offered, and wanted. */
     private measuring;
     /**
@@ -176,6 +209,20 @@ export declare class VirtualizeController implements ReactiveController {
      * host draws around the rows.
      */
     remaining(): number;
+    /**
+     * Whether a reader has come within one screen of the end of the set, true
+     * once for each length of it.
+     *
+     * For a host that asks for more items as a reader nears the end: it sends
+     * its request when this answers true, and the set growing lets it answer
+     * true again. False while the box has no height or the set no items, so a
+     * list that has not been laid out asks for nothing.
+     *
+     * `length` is what the answer is kept for, the count by default. A host
+     * whose count is a filtered view of what it holds passes what it holds, so
+     * new items that the filter hides still let it ask again.
+     */
+    endInSight(length?: number): boolean;
     /**
      * The two spacers' heights for the window, with item `kept` drawn too.
      *

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

@@ -1,3 +1,4 @@
+import { endInSight } from '../../utils/load-more/load-more.js';
 import { reportRuntime } from '../../utils/report-runtime/report-runtime.js';
 import { Heights } from './heights.js';
 const UNSTABLE = 10;
@@ -8,6 +9,7 @@ export class VirtualizeController {
         this.warned = false;
         this.window = { after: 0, before: 0, first: 0, last: 0 };
         this.owed = 0;
+        this.askedAt = -1;
         this.handleScroll = () => {
             this.settling = 0;
             this.measure();
@@ -46,7 +48,7 @@ export class VirtualizeController {
         this.watch();
         const box = this.options.container();
         const total = Math.max(0, this.options.count());
-        const size = Math.max(1, this.options.estimate());
+        const size = this.line();
         if (!box) {
             return;
         }
@@ -80,6 +82,36 @@ export class VirtualizeController {
         const last = Math.min(total, first + fits);
         return { after: Math.max(0, (total - last) * size), before: first * size, first, last };
     }
+    line() {
+        const estimate = Math.max(1, this.options.estimate());
+        return this.sample?.estimate === estimate ? this.sample.size : estimate;
+    }
+    sampleRows() {
+        const estimate = Math.max(1, this.options.estimate());
+        if (this.sample?.estimate === estimate) {
+            return;
+        }
+        const heights = new Map();
+        for (const { element, index } of this.options.rows?.() ?? []) {
+            heights.set(index, (heights.get(index) ?? 0) + element.getBoundingClientRect().height);
+        }
+        const seen = [...heights.values()].filter((height) => height > 0);
+        if (seen.length === 0) {
+            return;
+        }
+        const was = this.line();
+        const size = Math.max(1, seen.reduce((sum, height) => sum + height, 0) / seen.length);
+        this.sample = { estimate, size };
+        if (Math.abs(size - was) < 0.5) {
+            return;
+        }
+        const box = this.options.container();
+        if (box && box.scrollTop > 0) {
+            box.scrollTop = (box.scrollTop / was) * size;
+        }
+        this.settling = 0;
+        this.measure();
+    }
     measuring() {
         return this.options.rows !== undefined && (this.options.measured?.() ?? true);
     }
@@ -107,7 +139,7 @@ export class VirtualizeController {
         const top = Math.max(0, box.scrollTop);
         const bottom = top + box.clientHeight;
         if (!this.measuring()) {
-            const size = Math.max(1, this.options.estimate());
+            const size = this.line();
             const first = Math.min(Math.floor(top / size), total);
             return { first, last: Math.max(first, Math.min(total, Math.ceil(bottom / size))) };
         }
@@ -124,11 +156,22 @@ export class VirtualizeController {
         if (!box) {
             return 0;
         }
-        const length = this.measuring()
-            ? this.heights.total(total)
-            : total * Math.max(1, this.options.estimate());
+        const length = this.measuring() ? this.heights.total(total) : total * this.line();
         return Math.max(0, length - Math.max(0, box.scrollTop) - box.clientHeight);
     }
+    endInSight(length = Math.max(0, this.options.count())) {
+        if (this.options.count() <= 0 ||
+            !endInSight({
+                askedAt: this.askedAt,
+                count: length,
+                remaining: this.remaining(),
+                screen: this.options.container()?.clientHeight ?? 0,
+            })) {
+            return false;
+        }
+        this.askedAt = length;
+        return true;
+    }
     spacers(kept) {
         const { after, before, first, last } = this.window;
         if (kept === undefined || (kept >= first && kept < last)) {
@@ -149,6 +192,7 @@ export class VirtualizeController {
             this.owed = 0;
         }
         if (!this.measuring()) {
+            this.sampleRows();
             return;
         }
         const rows = this.options.rows?.();
@@ -190,7 +234,7 @@ export class VirtualizeController {
         this.owed += room;
     }
     sizeOf(index) {
-        return this.measuring() ? this.heights.at(index) : Math.max(1, this.options.estimate());
+        return this.measuring() ? this.heights.at(index) : this.line();
     }
     reveal(index, inset = 0, { align = 'nearest', behavior } = {}) {
         const box = this.options.container();
@@ -231,10 +275,11 @@ export class VirtualizeController {
         const total = Math.max(0, this.options.count());
         return this.measuring()
             ? this.heights.before(index, total)
-            : Math.max(0, Math.min(index, total)) * Math.max(1, this.options.estimate());
+            : Math.max(0, Math.min(index, total)) * this.line();
     }
     forget() {
         this.heights.forget();
+        this.sample = undefined;
     }
     report() {
         if (this.warned) {

package/dist/events/action.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A reader acted on a row: Enter on a list row, or a press in a list that
+ * selects nothing. Sent from the row, so `target` is the row acted on.
+ *
+ * Carries nothing, because the row is the whole of the answer. Not cancelable:
+ * a row with a link follows it and sends nothing, so there is no default left
+ * to refuse.
+ */
+export declare class HelixActionEvent extends Event {
+    static readonly eventName = "helix-action";
+    constructor();
+}

package/dist/events/action.js

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

package/dist/events/activate.d.ts

@@ -0,0 +1,22 @@
+import type { ActivateDetail } from './details.js';
+/**
+ * A set has made a different child current.
+ *
+ * The notification half of `helix-before-activate`, dispatched after the state
+ * has moved, so `currentTarget.active` is the new value and the detail is a fact
+ * rather than a proposal. `previous` is the value that was current before, where
+ * the set knows it, as Web Awesome's `wa-video-change` carries both.
+ *
+ * **Not cancelable**, for the reason every notification here is not: the
+ * decision was taken by the event before it, and a second refusable event for
+ * one transition is two answers to one question.
+ *
+ * **Prefixed, and it has to be.** `activate` unprefixed is not in any
+ * `*EventMap` in the DOM library, checked rather than assumed, but the prefix is
+ * what stops an event dispatched inside a shadow root and retargeted to the host
+ * being mistaken for something the host's own contents sent.
+ */
+export declare class HelixActivateEvent extends CustomEvent<ActivateDetail> {
+    static readonly eventName = "helix-activate";
+    constructor(detail: ActivateDetail);
+}

package/dist/events/activate.js

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

package/dist/events/aura-fallback.d.ts

@@ -0,0 +1,12 @@
+import type { AuraFallbackDetail } from './details.js';
+/**
+ * An aura stopped drawing its shader and shows its gradient, and says why.
+ *
+ * Sent each time it falls back, from the aura, which then matches
+ * `:state(fallback)` until it draws again. Not cancelable: there is nothing
+ * left to refuse.
+ */
+export declare class HelixAuraFallbackEvent extends CustomEvent<AuraFallbackDetail> {
+    static readonly eventName = "helix-aura-fallback";
+    constructor(detail: AuraFallbackDetail);
+}

package/dist/events/aura-fallback.js

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

package/dist/events/band.d.ts

@@ -0,0 +1,13 @@
+import type { BandDetail } from './details.js';
+/**
+ * A reading moved into another band: a meter whose value crossed `low`,
+ * `high` or `optimum` into `good`, `fair` or `poor`.
+ *
+ * Sent once for each crossing, not on every value, so a listener can say the
+ * change aloud or recolor something else on the page. Not cancelable, since
+ * the reading has already moved. Bubbles and is composed.
+ */
+export declare class HelixBandEvent extends CustomEvent<BandDetail> {
+    static readonly eventName = "helix-band";
+    constructor(detail: BandDetail);
+}

package/dist/events/band.js

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

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

@@ -0,0 +1,24 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A set is about to make a different child current, and can be refused.
+ *
+ * **Not a generic `helix-change`.** `Tabs` moving to another tab, `Tree` marking
+ * another row and `Steps` advancing are not a value changing, they are a set
+ * choosing, and the platform's word for a committed value would say the wrong
+ * thing. `active` names which child is current, so `activate` is the verb, and
+ * unlike `change` the platform has no claim on it.
+ *
+ * **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
+ * 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.
+ */
+export declare class HelixBeforeActivateEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-activate";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-activate.js

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

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

@@ -0,0 +1,26 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A value is about to change, and the change can be refused.
+ *
+ * **The request half of every value control.** It announces the value being
+ * *proposed*, before anything moves, so a listener calling `preventDefault()`
+ * refuses it and the control stays where it was. That is how a consumer takes
+ * one decision without declaring a mode, which is what 294 settled: the element
+ * always owns and applies its state, and refusing is the way to take it over.
+ *
+ * **The notification is native and separate.** Once this has gone out and the
+ * value has moved, the control announces it again under the platform's own
+ * name, `input` while a reader is editing and `change` when they are done, so
+ * `onChange` in React and `onchange=` in HTML both reach it and
+ * `currentTarget.value` is correct by the time a handler reads it. This event
+ * carries the detail because at the moment it fires the value is not on the
+ * element yet.
+ *
+ * **`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.
+ */
+export declare class HelixBeforeChangeEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-change";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-change.js

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

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

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

package/dist/events/before-close.js

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

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

@@ -0,0 +1,6 @@
+import type { ChangeDetail } from './details.js';
+/** A pane is about to collapse or reopen, and can be refused. */
+export declare class HelixBeforeCollapseEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-collapse";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-collapse.js

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

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

@@ -0,0 +1,6 @@
+import type { ChangeDetail } from './details.js';
+/** Source is about to be edited, and can be refused. */
+export declare class HelixBeforeEditEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-edit";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-edit.js

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

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

@@ -0,0 +1,17 @@
+import type { MoveDetail } from './details.js';
+/**
+ * Cards are about to move, and can be refused.
+ *
+ * **This is the controlled half, the way `helix-before-open` is for a
+ * dialog.** A board moves its own cards by default, writing `x` and `y` onto
+ * each one the way an input writes its own value. A consumer who keeps the
+ * positions in their own state calls `preventDefault()` here, writes what the
+ * detail says into that state, and renders the cards where it puts them.
+ *
+ * Sent for every step of a drag, so a controlled board follows the pointer
+ * rather than jumping on the drop.
+ */
+export declare class HelixBeforeMoveEvent extends CustomEvent<MoveDetail> {
+    static readonly eventName = "helix-before-move";
+    constructor(detail: MoveDetail);
+}

package/dist/events/before-move.js

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

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

@@ -0,0 +1,17 @@
+import type { OpenDetail } from './details.js';
+/**
+ * Fired when an element is about to open.
+ *
+ * Cancelable: `preventDefault()` refuses the change, and the element stays
+ * closed. Paired with `helix-before-close` rather than being one event carrying a
+ * boolean, so a listener that only cares about one direction says so by which
+ * event it listens for.
+ *
+ * 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.
+ */
+export declare class HelixBeforeOpenEvent extends CustomEvent<OpenDetail> {
+    static readonly eventName = "helix-before-open";
+    constructor();
+}

package/dist/events/before-open.js

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

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

@@ -0,0 +1,13 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A sandbox's panel is about to change height, and can be refused.
+ *
+ * The sibling of `helix-before-split`, and named for the divider rather than for
+ * the axis because a reader binding one of the two is choosing which divider they
+ * care about. `value` is pixels here and a percentage there, which is what each
+ * property already publishes.
+ */
+export declare class HelixBeforePanelResizeEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-panel-resize";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-panel-resize.js

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

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

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