@hyperfixi/engine 3.3.0

package/dist/commands/dom-more.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The rest of the DOM commands: `hide` / `show`, `take`, `measure`, `make`,
+ * `append`, `swap`, and the family that applies one action to a target
+ * (`focus`, `blur`, `select`, `empty` / `clear`, `reset`, `open`, `close`).
+ * Follows upstream `parsetree/commands/dom.js`, `basic.js` and `setters.js`.
+ */
+import type { AttributeRefNode, ClassRefNode, Cmd, Expr } from '../ast';
+import type { Grammar } from '../parser';
+export interface VisibilityNode extends Cmd {
+    type: 'hideCommand' | 'showCommand';
+    target: Expr;
+    /** `with <strategy>`: display (default), visibility, opacity, hidden, or a configured one. */
+    strategy?: string;
+    /** `show … with display:inline-block`: the value to show with. */
+    arg?: string;
+    when?: Expr;
+}
+export declare function hideShow(g: Grammar): void;
+export interface TakeNode extends Cmd {
+    type: 'takeCommand';
+    classRefs: ClassRefNode[];
+    attributeRef?: AttributeRefNode;
+    from?: Expr;
+    for: Expr;
+    /** `with` / `giving`: what the elements that lose the class or attribute get instead. */
+    replacementClass?: ClassRefNode;
+    replacementValue?: Expr;
+}
+/** `take .class [with .other] [from <others> [giving .other]] [for <target>]`, or the same with `@attr`. */
+export declare function take(g: Grammar): void;
+export interface MeasureNode extends Cmd {
+    type: 'measureCommand';
+    target: Expr;
+    properties: string[];
+}
+/** `measure [<target>'s] [x, y, width, …]`: the result holds every measurement; named ones also become locals. */
+export declare function measure(g: Grammar): void;
+export interface TargetNode extends Cmd {
+    type: string;
+    /** Absent means `me`. */
+    target?: Expr;
+}
+export declare function targetCommands(g: Grammar): void;
+export declare function openClose(g: Grammar): void;
+export interface MakeNode extends Cmd {
+    type: 'makeCommand';
+    /** `<tag#id.class/>`, or a constructor. */
+    value: Expr;
+    args: Expr[];
+    /** `called <name>`. */
+    called?: Expr;
+}
+export declare function make(g: Grammar): void;
+export interface AppendNode extends Cmd {
+    type: 'appendCommand';
+    value: Expr;
+    /** Absent means the result (`it`). */
+    target?: Expr;
+}
+/** `append <value> [to <target>]`: push to a list, add to a set, add content to an element, or concatenate. */
+export declare function append(g: Grammar): void;
+export interface SwapNode extends Cmd {
+    type: 'swapCommand';
+    first: Expr;
+    second: Expr;
+}
+/** `swap <a> with <b>`: exchange two values, or two elements' places in the document. */
+export declare function swap(g: Grammar): void;

package/dist/commands/dom.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `add`, `remove`, `toggle`. Follows upstream `parsetree/commands/dom.js`.
+ */
+import type { AttributeRefNode, ClassRefNode, Cmd, Expr, StyleLiteralNode } from '../ast';
+import type { Grammar, Parser } from '../parser';
+export interface AddNode extends Cmd {
+    type: 'addCommand';
+    classRefs?: ClassRefNode[];
+    attributeRef?: AttributeRefNode;
+    css?: StyleLiteralNode;
+    /** `add <value> to <array or set>`. */
+    value?: Expr;
+    to: Expr;
+    when?: Expr;
+}
+export declare function add(g: Grammar): void;
+export interface RemoveNode extends Cmd {
+    type: 'removeCommand';
+    classRefs?: ClassRefNode[];
+    attributeRef?: AttributeRefNode;
+    css?: StyleLiteralNode;
+    /** `remove <element>` or `remove <item> from <collection>`. */
+    element?: Expr;
+    from?: Expr;
+    when?: Expr;
+}
+export declare function remove(g: Grammar): void;
+export type Visibility = (op: 'hide' | 'show' | 'toggle', elt: HTMLElement, arg?: string) => void;
+export declare const strategies: Record<string, Visibility>;
+/** The strategy named in `with <name>`, the configured default, or `display`. */
+export declare function strategy(p: Parser, name?: string): Visibility;
+export interface ToggleNode extends Cmd {
+    type: 'toggleCommand';
+    classRefs?: ClassRefNode[];
+    /** `toggle between .a and .b` / `toggle between @a and @b`. */
+    between?: [ClassRefNode, ClassRefNode] | [AttributeRefNode, AttributeRefNode];
+    attributeRef?: AttributeRefNode;
+    /** `toggle *display`. */
+    styleProp?: string;
+    /** `toggle <assignable> between <values>`. */
+    target?: Expr;
+    betweenValues?: Expr[];
+    on?: Expr;
+    /** `for <duration>`. */
+    time?: Expr;
+    /** `until <event> [from <source>]`. */
+    until?: string;
+    from?: Expr;
+}
+export declare function toggle(g: Grammar): void;

package/dist/commands/events.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `send` / `trigger` and `wait`. Follows upstream `parsetree/commands/events.js`.
+ */
+import type { Cmd, Expr, NamedArgsNode } from '../ast';
+import type { Grammar } from '../parser';
+export interface SendNode extends Cmd {
+    type: 'sendCommand';
+    event: string;
+    details?: NamedArgsNode;
+    to: Expr;
+}
+/** `send <event>[(details)] [to <target>]`; `trigger` is the same with `on`. */
+export declare function send(g: Grammar): void;
+export interface WaitNode extends Cmd {
+    type: 'waitCommand';
+    /** `wait <duration>`. */
+    time?: Expr;
+    /** `wait for <event>[(args)] or <duration> … [from <source>]`. */
+    events?: ({
+        event: string;
+        args: string[];
+    } | Expr)[];
+    from?: Expr;
+}
+export declare function wait(g: Grammar): void;

package/dist/commands/js.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `js … end`: inline JavaScript, as a command and as a top-level feature.
+ * Follows upstream `parsetree/commands/execution.js` and `features/js.js`.
+ *
+ * This is the one module that compiles source with `Function`. A bundle for a
+ * page with a strict Content-Security-Policy leaves it out.
+ */
+import type { Cmd, Feature } from '../ast';
+import type { Grammar } from '../parser';
+export interface JsNode extends Cmd {
+    type: 'jsCommand';
+    source: string;
+    /** Hyperscript variables passed in as parameters: `js(x, y) … end`. */
+    inputs: string[];
+}
+export interface JsFeature extends Feature {
+    type: 'jsFeature';
+    source: string;
+    /** Function declarations the block exposes as globals. */
+    functions: string[];
+}
+export declare function js(g: Grammar): void;

package/dist/commands/loops.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `repeat` / `for`, `break`, `continue`, `tell`. Follows upstream
+ * `parsetree/commands/controlflow.js`.
+ */
+import type { Cmd, Expr } from '../ast';
+import type { Grammar } from '../parser';
+export interface RepeatNode extends Cmd {
+    type: 'repeatCommand';
+    /** `for x in <expression>`; `repeat in <expression>` binds `it`. */
+    identifier?: string;
+    indexIdentifier?: string;
+    expression?: Expr;
+    times?: Expr;
+    /** `while <cond>` or `until <cond>`; `bottomTested` when it follows the body. */
+    condition?: Expr;
+    until: boolean;
+    bottomTested: boolean;
+    forever: boolean;
+    /** `until event <name> [from <source>]`. */
+    event?: string;
+    from?: Expr;
+    body: Cmd[];
+    elseBranch?: Cmd[];
+}
+export declare function repeat(g: Grammar): void;
+/** `break` and `continue`: signals the enclosing loop acts on. */
+export declare function loopControl(g: Grammar): void;
+export interface TellNode extends Cmd {
+    type: 'tellCommand';
+    value: Expr;
+    body: Cmd[];
+}
+/** `tell <targets> <commands> [end]`: run the body once per target, with `you` bound to it. */
+export declare function tell(g: Grammar): void;

package/dist/commands/misc.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `log`, `call` / `get`, and the pseudo-command (`foo()` or `me.focus()` used as
+ * a statement). Follows upstream `basic.js`, `execution.js`, `pseudoCommand.js`.
+ */
+import type { Cmd, Expr } from '../ast';
+import type { Grammar } from '../parser';
+export interface LogNode extends Cmd {
+    type: 'logCommand';
+    values: Expr[];
+    /** `log x with console.warn`. */
+    logger?: Expr;
+}
+export declare function log(g: Grammar): void;
+export interface GetNode extends Cmd {
+    type: 'getCommand';
+    value: Expr;
+}
+/** `get <expr>` / `call <function call>`: evaluate and keep the value as `it`. */
+export declare function get_(g: Grammar): void;
+export interface PseudoNode extends Cmd {
+    type: 'pseudoCommand';
+    value: Expr;
+    /** `reload() the location`: the call's receiver, written after it. */
+    target?: Expr;
+}
+export declare function pseudoCommand(g: Grammar): void;
+export interface AskNode extends Cmd {
+    type: 'askCommand' | 'answerCommand';
+    message: Expr;
+    /** `answer … with <a> or <b>`: the two choices of a confirmation. */
+    choices?: [Expr, Expr];
+}
+/** `ask <message>` prompts; `answer <message> [with <a> or <b>]` alerts or confirms. */
+export declare function askAnswer(g: Grammar): void;
+/** `breakpoint`: stop in the debugger. */
+export declare function breakpoint(g: Grammar): void;

package/dist/commands/morph.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `morph <target> to <content>`: change an element's tree into another, keeping the
+ * nodes that can be kept, so identity, focus and listeners survive.
+ *
+ * The algorithm follows upstream `core/runtime/morph.js` (itself the htmx 4 morph by
+ * Michael West). Nodes are matched by id first, then by shape; a node with an id that
+ * appears on both sides is moved rather than rebuilt.
+ */
+import type { Cmd, Expr } from '../ast';
+import type { Grammar } from '../parser';
+/** Morph `old` to match `content`: an HTML string, an element or a fragment. */
+export declare function morphTo(old: Element, content: unknown): void;
+export interface MorphNode extends Cmd {
+    type: 'morphCommand';
+    target: Expr;
+    content: Expr;
+}
+export declare function morph(g: Grammar): void;

package/dist/commands/pick.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `pick`: take part of a list or string, or match a regular expression.
+ * Follows upstream `parsetree/commands/basic.js`.
+ */
+import type { Cmd, Expr } from '../ast';
+import type { Grammar } from '../parser';
+export interface PickNode extends Cmd {
+    type: 'pickCommand';
+    variant: 'first' | 'last' | 'random' | 'range' | 'match' | 'matches';
+    root: Expr;
+    /** How many, for first / last / random. */
+    count?: Expr;
+    /** Range bounds; `start` and `end` are the list's own ends. */
+    from?: Expr;
+    to?: Expr;
+    toEnd?: boolean;
+    /** `inclusive` includes the end index; `exclusive` skips the start index. */
+    bounds?: 'inclusive' | 'exclusive';
+    re?: Expr;
+    flags?: string;
+}
+export declare function pick(g: Grammar): void;

package/dist/commands/platform.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `fetch`, `go`, `scroll`. Follows upstream `parsetree/commands/basic.js`.
+ */
+import type { Cmd, Expr } from '../ast';
+import type { Grammar } from '../parser';
+export interface FetchNode extends Cmd {
+    type: 'fetchCommand';
+    url: Expr;
+    options?: Expr;
+    /** How the response becomes the result: text (default), json, html, the response itself, or a named conversion. */
+    as: string;
+    dontThrow: boolean;
+}
+/** `fetch <url> [as <type>] [with <options>] [as <type>] [do not throw]`. */
+export declare function fetchCommand(g: Grammar): void;
+interface ScrollSpec {
+    target: Expr;
+    offset?: Expr;
+    /** +1 or -1 when an offset follows the target. */
+    sign: number;
+    options: ScrollIntoViewOptions;
+    container?: Expr;
+}
+export interface ScrollNode extends Cmd {
+    type: 'scrollCommand';
+    /** `scroll to …`. */
+    to?: ScrollSpec;
+    /** `scroll [<target>] [up|down|left|right] by <n> [px]`. */
+    target?: Expr;
+    direction?: string;
+    by?: Expr;
+    behavior?: ScrollBehavior;
+}
+export declare function scroll(g: Grammar): void;
+export interface GoNode extends Cmd {
+    type: 'goCommand';
+    back: boolean;
+    target?: Expr;
+    scroll?: ScrollSpec;
+    newWindow: boolean;
+}
+/** `go back`, `go to url <url> [in new window]`, `go to <url or element>`, `go to the top of <element>`. */
+export declare function go(g: Grammar): void;
+export {};

package/dist/commands/setters.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `set`, `increment`, `decrement`, `put`. Follows upstream `parsetree/commands/setters.js`.
+ *
+ * Every write goes through the target expression's own `lhs` / `put` pair, so a
+ * command never inspects what kind of expression it was given.
+ */
+import type { Cmd, Expr, ObjectNode } from '../ast';
+import type { Grammar, Parser } from '../parser';
+export interface SetNode extends Cmd {
+    type: 'setCommand';
+    target: Expr;
+    value?: Expr;
+    /** `set { … } on <target>`: copy the object's properties onto the target. */
+    object?: ObjectNode;
+}
+export declare function set(g: Grammar): void;
+export declare function parseSet(p: Parser, start: number): SetNode;
+export interface DefaultNode extends Cmd {
+    type: 'defaultCommand';
+    target: Expr;
+    value: Expr;
+}
+/** `default <target> to <value>`: assign only when the target is null, undefined or empty. */
+export declare function defaultCommand(g: Grammar): void;
+export interface StepNode extends Cmd {
+    type: 'incrementCommand' | 'decrementCommand';
+    target: Expr;
+    amount?: Expr;
+}
+/** `increment` and `decrement`: the same rule with the sign flipped. */
+export declare function increment(g: Grammar): void;
+export interface PutNode extends Cmd {
+    type: 'putCommand';
+    value: Expr;
+    operation: 'into' | 'before' | 'after' | 'start' | 'end';
+    target: Expr;
+}
+export declare function put(g: Grammar): void;