@fusion.dev/helix-core 0.144.0 → 0.146.0

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);
+}

package/dist/events/before-pin.js

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

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

@@ -0,0 +1,14 @@
+import type { ReconnectDetail } from './details.js';
+/**
+ * A connection's end is about to move to another card or another side, and can
+ * be refused.
+ *
+ * **A move, not a request, and that is the difference from `helix-connect`.**
+ * The connection is already an element on the page, so the board rewrites its
+ * ends itself, the way it writes a card's position onto the card; a page that
+ * holds its connections in state refuses this and writes them there.
+ */
+export declare class HelixBeforeReconnectEvent extends CustomEvent<ReconnectDetail> {
+    static readonly eventName = "helix-before-reconnect";
+    constructor(detail: ReconnectDetail);
+}

package/dist/events/before-reconnect.js

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

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

@@ -0,0 +1,15 @@
+import type { RelabelDetail } from './details.js';
+/**
+ * A label the board draws is about to change, and can be refused.
+ *
+ * **The board edits what it draws and asks for what it does not.** A
+ * connection's label and a group's name are drawn by the board from an
+ * attribute, so the board edits them in place and writes the attribute back,
+ * the way it writes a card's position; a page holding them in state refuses
+ * this and writes them there. A card's own content is the page's, which is why
+ * that is `helix-canvas-edit`, a request, rather than this.
+ */
+export declare class HelixBeforeRelabelEvent extends CustomEvent<RelabelDetail> {
+    static readonly eventName = "helix-before-relabel";
+    constructor(detail: RelabelDetail);
+}

package/dist/events/before-relabel.js

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

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

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

package/dist/events/before-resize.js

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

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

@@ -0,0 +1,12 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * The divider between a sandbox's panes is about to move, and can be refused.
+ *
+ * Its own verb rather than a `helix-before-resize` carrying which divider moved:
+ * a sandbox has two, and they were told apart by a field on a detail every other
+ * request in this file also carries.
+ */
+export declare class HelixBeforeSplitEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-split";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-split.js

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

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

@@ -0,0 +1,23 @@
+import type { ToggleDetail } 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.
+ *
+ * The notification 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.
+ *
+ * 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.
+ */
+export declare class HelixBeforeToggleEvent extends CustomEvent<ToggleDetail> {
+    static readonly eventName = "helix-before-toggle";
+    constructor(detail: ToggleDetail);
+}

package/dist/events/before-toggle.js

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

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

@@ -0,0 +1,16 @@
+/**
+ * A reader asked to edit a card: a double-click, or Enter or F2 on it.
+ *
+ * **A request, because what a card holds is the page's.** Text, a picture, a
+ * chart: the board cannot know what editing any of those means, so it says
+ * which card and the page opens its own editor, in place, in a dialog, or in a
+ * panel beside the board.
+ */
+export declare class HelixCanvasEditEvent extends CustomEvent<{
+    name: string;
+}> {
+    static readonly eventName = "helix-canvas-edit";
+    constructor(detail: {
+        name: string;
+    });
+}

package/dist/events/canvas-edit.js

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

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

@@ -0,0 +1,13 @@
+import type { ViewportPanDetail } from './details.js';
+/**
+ * The board moved, which on a canvas is a fact rather than a request.
+ *
+ * **`Map` asks and `Canvas` tells, and the difference is who draws.** A map is
+ * somebody else's, so the frame can only ask them to move it; a canvas is drawn
+ * here from a document, so the same press moves it and this says that it did.
+ * The detail is the same shape either way, being a direction and a distance.
+ */
+export declare class HelixCanvasPanEvent extends CustomEvent<ViewportPanDetail> {
+    static readonly eventName = "helix-canvas-pan";
+    constructor(detail: ViewportPanDetail);
+}

package/dist/events/canvas-pan.js

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

package/dist/events/canvas-view.d.ts

@@ -0,0 +1,14 @@
+import type { CanvasView } from './details.js';
+/**
+ * The board's view changed, however it changed: a drag, the wheel, a press on
+ * a control, a card brought into view, or the board fitting itself.
+ *
+ * **One event for all of them**, because what a consumer keeping a minimap or a
+ * saved position in step needs is where the board is now, not which of six
+ * gestures put it there; `helix-canvas-pan` and `helix-canvas-zoom` still say
+ * which control was pressed. Sent for every step of a drag, the way `input` is.
+ */
+export declare class HelixCanvasViewEvent extends CustomEvent<CanvasView> {
+    static readonly eventName = "helix-canvas-view";
+    constructor(detail: CanvasView);
+}

package/dist/events/canvas-view.js

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

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

@@ -0,0 +1,6 @@
+import type { ViewportZoomDetail } from './details.js';
+/** The board zoomed, and told, for the same reason. */
+export declare class HelixCanvasZoomEvent extends CustomEvent<ViewportZoomDetail> {
+    static readonly eventName = "helix-canvas-zoom";
+    constructor(detail: ViewportZoomDetail);
+}

package/dist/events/canvas-zoom.js

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

package/dist/events/caret.d.ts

@@ -0,0 +1,17 @@
+import type { CaretDetail } from './details.js';
+/**
+ * Fired when the cursor moves in a text editor.
+ *
+ * Not cancelable, unlike everything else here. The others announce something
+ * about to happen and a listener can refuse it; this one reports where the
+ * caret already is, and there is nothing left to refuse.
+ *
+ * It fires on every keystroke and every arrow press, which is why the status
+ * bar reads it from the DOM rather than through a framework's state: routing a
+ * caret position through React would re-render the workbench on every cursor
+ * move.
+ */
+export declare class HelixCaretEvent extends CustomEvent<CaretDetail> {
+    static readonly eventName = "helix-caret";
+    constructor(detail: CaretDetail);
+}

package/dist/events/caret.js

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

package/dist/events/clear.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A reader cleared the value: an input's clear button emptied the field, or a
+ * clearable rating went back to unrated.
+ *
+ * Sent after the value is cleared, and after the `input` and `change` the
+ * clear sends. Carries nothing, because the value is the cleared one.
+ */
+export declare class HelixClearEvent extends Event {
+    static readonly eventName = "helix-clear";
+    constructor();
+}

package/dist/events/clear.js

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

package/dist/events/collapse.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * A pane shut or reopened.
+ *
+ * The notification half of `helix-before-collapse`, sent once `collapsed` has
+ * moved. `detail.value` is the side that is shut, or empty where both panes
+ * are open. Not cancelable: the decision was the request's.
+ */
+export declare class HelixCollapseEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-collapse";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/collapse.js

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

package/dist/events/complete.d.ts

@@ -0,0 +1,26 @@
+import type { CompleteDetail } from './details.js';
+/**
+ * Fired when a control that fills up has filled.
+ *
+ * The moment a code entry exists for: a six-character field is worth submitting
+ * the instant the sixth character lands, and a consumer watching `helix-change`
+ * has to know the length and compare it on every keystroke to find that moment
+ * themselves.
+ *
+ * Separate from `helix-change` rather than a flag on it, because they are
+ * answered by different code: one keeps a value in step and the other decides
+ * whether to send a form. A listener that only cares about the second says so by
+ * which event it listens for.
+ *
+ * `complete` is free as a verb. React's synthetic system claims `change`,
+ * `input`, `submit`, `reset`, `copy`, `paste`, `scroll`, `drag`, `focus` and
+ * `blur`, measured, and this is none of them.
+ *
+ * Not cancelable. It reports that something already happened, which is the same
+ * reason `helix-caret` is not: there is nothing left to refuse once the last
+ * character is in the box.
+ */
+export declare class HelixCompleteEvent extends CustomEvent<CompleteDetail> {
+    static readonly eventName = "helix-complete";
+    constructor(detail: CompleteDetail);
+}

package/dist/events/complete.js

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

package/dist/events/connect.d.ts

@@ -0,0 +1,14 @@
+import type { ConnectDetail } from './details.js';
+/**
+ * A reader asked for two cards to be joined.
+ *
+ * **A request with no default, which is the difference from a move.** A board
+ * writes a card's position onto the card, because the card is already there.
+ * A connection is a new element, and a board that added one to markup React
+ * renders would have it put back or thrown away on the next render. So the board
+ * asks and the page adds the `helix-canvas-edge`, the way `Map` asks to be panned.
+ */
+export declare class HelixConnectEvent extends CustomEvent<ConnectDetail> {
+    static readonly eventName = "helix-connect";
+    constructor(detail: ConnectDetail);
+}

package/dist/events/connect.js

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

package/dist/events/console.d.ts

@@ -0,0 +1,13 @@
+import type { ConsoleDetail } from './details.js';
+/**
+ * Fired when something being previewed writes to the console.
+ *
+ * Carries text rather than the logged values. The preview is a separate
+ * document, so what arrives has crossed `postMessage` and been through
+ * structured clone: a DOM node or a function does not survive that, and half a
+ * value is worse than a string of it.
+ */
+export declare class HelixConsoleEvent extends CustomEvent<ConsoleDetail> {
+    static readonly eventName = "helix-console";
+    constructor(detail: ConsoleDetail);
+}

package/dist/events/console.js

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

package/dist/events/copy-error.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A press put nothing on the clipboard: the browser did not allow the write,
+ * such as on a page without the clipboard permission, or there was nothing to
+ * copy.
+ */
+export declare class HelixCopyErrorEvent extends Event {
+    static readonly eventName = "helix-copy-error";
+    constructor();
+}

package/dist/events/copy-error.js

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

package/dist/events/copy.d.ts

@@ -0,0 +1,12 @@
+import type { CopyDetail } from './details.js';
+/**
+ * Something was copied to the clipboard.
+ *
+ * Not cancelable, and deliberately: it is announced after the write, because a
+ * clipboard write is a permission the platform may refuse and there is nothing
+ * useful to report until it has either happened or not.
+ */
+export declare class HelixCopyEvent extends CustomEvent<CopyDetail> {
+    static readonly eventName = "helix-copy";
+    constructor(detail: CopyDetail);
+}

package/dist/events/copy.js

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

package/dist/events/create.d.ts

@@ -0,0 +1,18 @@
+import type { CreateDetail } from './details.js';
+/**
+ * The reader asked for something the list does not hold.
+ *
+ * Cancelable, and announced before anything is applied, because the options are
+ * the consumer's own light DOM and no component here writes into it. What the
+ * control can do is say what was asked for and take the value; putting an
+ * option in the list, or a row in a database, is the consumer's, and a consumer
+ * who validates first refuses this and adds nothing.
+ *
+ * The detail carries the text as typed, not a slug of it. Trimming or lowering
+ * it here would be this element deciding what a name means, and a consumer who
+ * wants an identifier can make one from what they were given.
+ */
+export declare class HelixCreateEvent extends CustomEvent<CreateDetail> {
+    static readonly eventName = "helix-create";
+    constructor(detail: CreateDetail);
+}