@hyperfixi/core 3.3.0 → 4.0.1

package/dist/ast/command-slots.d.ts

@@ -1,140 +0,0 @@
-import type { ASTNode, ExpressionNode } from '../types/core';
-import type { BodyOps } from '../types/program';
-export declare const GENERIC_SLOT_KEYS: readonly ["when", "where", "debounce", "throttle"];
-export type GenericSlotKey = (typeof GENERIC_SLOT_KEYS)[number];
-export declare const COMMAND_SLOTS: {
-    readonly add: readonly ["to"];
-    readonly append: readonly ["to"];
-    readonly beep: readonly [];
-    readonly blur: readonly [];
-    readonly break: readonly [];
-    readonly breakpoint: readonly [];
-    readonly call: readonly [];
-    readonly clear: readonly [];
-    readonly close: readonly [];
-    readonly continue: readonly [];
-    readonly copy: readonly ["to"];
-    readonly decrement: readonly ["by"];
-    readonly default: readonly ["to"];
-    readonly empty: readonly [];
-    readonly exit: readonly [];
-    readonly fetch: readonly ["as", "body", "doNotThrow", "with"];
-    readonly focus: readonly [];
-    readonly get: readonly [];
-    readonly go: readonly ["back", "behavior", "by", "forward", "in", "of", "position", "url"];
-    readonly halt: readonly ["the"];
-    readonly hide: readonly ["with"];
-    readonly if: readonly [];
-    readonly increment: readonly ["by"];
-    readonly install: readonly ["on"];
-    readonly js: readonly [];
-    readonly log: readonly [];
-    readonly make: readonly ["a", "an", "called", "from"];
-    readonly measure: readonly ["of", "set"];
-    readonly morph: readonly ["on", "strategy", "viewTransition", "with"];
-    readonly open: readonly ["as"];
-    readonly pick: readonly ["count", "flags", "rangeEnd", "rangeMode", "rangeStart", "regex", "variant"];
-    readonly prepend: readonly ["to"];
-    readonly process: readonly ["viewTransition"];
-    readonly 'pseudo-command': readonly ["at", "from", "into", "on", "to", "with"];
-    readonly push: readonly ["title"];
-    readonly put: readonly ["after", "at", "at end of", "at start of", "before", "into", "viewTransition"];
-    readonly remove: readonly ["from"];
-    readonly render: readonly ["with"];
-    readonly repeat: readonly ["bottomTested", "event", "for", "from", "in", "index", "loopType", "times", "until", "while"];
-    readonly replace: readonly ["title"];
-    readonly reset: readonly [];
-    readonly return: readonly [];
-    readonly scroll: readonly ["behavior", "by", "direction", "of", "position"];
-    readonly select: readonly [];
-    readonly send: readonly ["detail", "on", "to", "with"];
-    readonly set: readonly ["on", "to"];
-    readonly settle: readonly ["for"];
-    readonly show: readonly ["with"];
-    readonly start: readonly ["transitionName"];
-    readonly swap: readonly ["strategy", "viewTransition", "with"];
-    readonly take: readonly ["for", "from"];
-    readonly tell: readonly [];
-    readonly throw: readonly [];
-    readonly toggle: readonly ["as", "between", "for", "from", "on", "until"];
-    readonly unless: readonly [];
-    readonly transition: readonly ["from", "on", "over", "pairs", "to", "using", "with"];
-    readonly trigger: readonly ["on", "to", "with"];
-    readonly wait: readonly [];
-};
-export type SlottedCommandName = keyof typeof COMMAND_SLOTS;
-export declare const COMMAND_ARITY: {
-    readonly add: readonly [1, 2];
-    readonly append: readonly [1, 1];
-    readonly beep: readonly [0, null];
-    readonly blur: readonly [0, 1];
-    readonly break: readonly [0, 0];
-    readonly breakpoint: readonly [0, 0];
-    readonly call: readonly [1, 1];
-    readonly clear: readonly [1, 1];
-    readonly close: readonly [0, 1];
-    readonly continue: readonly [0, 0];
-    readonly copy: readonly [1, 1];
-    readonly decrement: readonly [1, 2];
-    readonly default: readonly [1, 2];
-    readonly empty: readonly [0, 1];
-    readonly exit: readonly [0, 0];
-    readonly fetch: readonly [1, 1];
-    readonly focus: readonly [0, 1];
-    readonly get: readonly [1, 1];
-    readonly go: readonly [0, 1];
-    readonly halt: readonly [0, 1];
-    readonly hide: readonly [0, 1];
-    readonly if: readonly [2, 3];
-    readonly increment: readonly [1, 2];
-    readonly install: readonly [1, 2];
-    readonly js: readonly [2, 2];
-    readonly log: readonly [0, null];
-    readonly make: readonly [0, 1];
-    readonly measure: readonly [0, 2];
-    readonly morph: readonly [1, 3];
-    readonly open: readonly [0, 1];
-    readonly pick: readonly [1, null];
-    readonly prepend: readonly [1, 1];
-    readonly process: readonly [1, 1];
-    readonly 'pseudo-command': readonly [1, 3];
-    readonly push: readonly [1, 1];
-    readonly put: readonly [1, 2];
-    readonly remove: readonly [0, 1];
-    readonly render: readonly [1, 1];
-    readonly repeat: readonly [1, 2];
-    readonly replace: readonly [1, 1];
-    readonly reset: readonly [0, 1];
-    readonly return: readonly [0, 1];
-    readonly scroll: readonly [0, 1];
-    readonly select: readonly [0, 1];
-    readonly send: readonly [1, 1];
-    readonly set: readonly [1, 2];
-    readonly settle: readonly [0, 1];
-    readonly show: readonly [0, 1];
-    readonly start: readonly [1, null];
-    readonly swap: readonly [1, 3];
-    readonly take: readonly [1, 1];
-    readonly tell: readonly [2, null];
-    readonly throw: readonly [0, 1];
-    readonly toggle: readonly [0, 2];
-    readonly transition: readonly [1, 2];
-    readonly trigger: readonly [1, 1];
-    readonly unless: readonly [2, 3];
-    readonly wait: readonly [1, 2];
-};
-export type SlotKey<K extends SlottedCommandName> = (typeof COMMAND_SLOTS)[K][number] | GenericSlotKey;
-export type SlotMap<K extends SlottedCommandName> = Partial<Record<SlotKey<K>, ExpressionNode>>;
-type Repeat<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Repeat<T, N, [...R, T]>;
-type TupleRange<T, Min extends number, Max extends number, R extends T[] = Repeat<T, Min>> = R['length'] extends Max ? R : R | TupleRange<T, Min, Max, [...R, T]>;
-export type ArgsOf<K extends SlottedCommandName> = [K] extends [
-    (typeof COMMAND_ARITY)[K] extends readonly [number, number] ? K : never
-] ? (typeof COMMAND_ARITY)[K] extends readonly [number, infer Max extends number] ? TupleRange<ASTNode, 0, Max> : ASTNode[] : ASTNode[];
-export interface CommandRaw<K extends SlottedCommandName> {
-    args: ArgsOf<K>;
-    modifiers: Partial<Record<SlotKey<K>, ExpressionNode>>;
-    commandName?: string;
-    bodies?: BodyOps;
-}
-export {};
-//# sourceMappingURL=command-slots.d.ts.map

package/dist/ast/guards.d.ts

@@ -1,15 +0,0 @@
-import type { SyntaxNode, SyntaxKind, IdentifierNode, LiteralNode, SelectorNode, CommandNode, PropertyOfExpressionNode, PropertyAccessNode } from './nodes';
-export declare function isNode(value: unknown): value is SyntaxNode;
-export declare function isNodeOfKind<K extends SyntaxKind>(value: unknown, kind: K): value is Extract<SyntaxNode, {
-    type: K;
-}>;
-export declare function assertNodeOfKind<K extends SyntaxKind>(value: unknown, kind: K): Extract<SyntaxNode, {
-    type: K;
-}>;
-export declare function isIdentifierNode(value: unknown): value is IdentifierNode;
-export declare function isLiteralNode(value: unknown): value is LiteralNode;
-export declare function isSelectorNode(value: unknown): value is SelectorNode;
-export declare function isCommandNode(value: unknown): value is CommandNode;
-export declare function isPropertyOfExpressionNode(value: unknown): value is PropertyOfExpressionNode;
-export declare function isPropertyAccessNode(value: unknown): value is PropertyAccessNode;
-//# sourceMappingURL=guards.d.ts.map

package/dist/ast/legacy.d.ts

@@ -1,15 +0,0 @@
-import type { ASTNode, ExpressionNode } from '../types/base-types';
-import type { CommandNode as LegacyCommandNode } from '../types/core';
-import type { Expr, Stmt, SyntaxNode } from './nodes';
-export type AnyNode = SyntaxNode | ASTNode;
-export declare function toLegacyNode(node: AnyNode): ASTNode;
-export declare function toLegacyNodes(nodes: readonly AnyNode[]): ASTNode[];
-export declare function toLegacyExpression(node: Expr): ExpressionNode;
-export declare function toLegacyExpressions(nodes: Expr[]): ExpressionNode[];
-export declare function toLegacyExpressionMap(modifiers: Record<string, Expr>): Record<string, ExpressionNode>;
-export declare function fromLegacyCommands(nodes: ReadonlyArray<LegacyCommandNode | ASTNode>): Stmt[];
-export declare function fromLegacyExpression(node: ASTNode): Expr;
-export declare function fromHybridStatements(body: ReadonlyArray<{
-    readonly type: string;
-}>): Stmt[];
-//# sourceMappingURL=legacy.d.ts.map

package/dist/ast/nodes.d.ts

@@ -1,243 +0,0 @@
-import type { ParseDiagnostic } from '../types/base-types';
-import type { SlotKey, SlottedCommandName } from './command-slots';
-export interface BaseNode {
-    readonly type: string;
-    readonly start?: number;
-    readonly end?: number;
-    readonly line?: number;
-    readonly column?: number;
-    readonly raw?: string;
-    readonly diagnostics?: readonly ParseDiagnostic[];
-}
-export interface LiteralNode extends BaseNode {
-    readonly type: 'literal';
-    readonly value: unknown;
-    readonly raw?: string;
-    readonly dataType?: 'string' | 'number' | 'boolean' | 'duration';
-}
-export interface StringNode extends BaseNode {
-    readonly type: 'string';
-    readonly value: string;
-}
-export interface IdentifierNode extends BaseNode {
-    readonly type: 'identifier';
-    readonly name: string;
-    readonly scope?: 'local' | 'element' | 'global';
-}
-export interface SelectorNode extends BaseNode {
-    readonly type: 'selector';
-    readonly value: string;
-    readonly selector?: string;
-    readonly selectorType?: string;
-    readonly fromQuery?: boolean;
-    readonly raw?: string;
-}
-export interface AttributeAccessNode extends BaseNode {
-    readonly type: 'attributeAccess';
-    readonly attributeName: string;
-}
-export interface CssPropertyNode extends BaseNode {
-    readonly type: 'cssProperty';
-    readonly name: string;
-}
-export interface BinaryExpressionNode extends BaseNode {
-    readonly type: 'binaryExpression';
-    readonly operator: string;
-    readonly left: Expr;
-    readonly right: Expr;
-    readonly coerceNumeric?: boolean;
-    readonly ignoringCase?: boolean;
-}
-export interface UnaryExpressionNode extends BaseNode {
-    readonly type: 'unaryExpression';
-    readonly operator: string;
-    readonly operand: Expr;
-    readonly argument?: Expr;
-    readonly prefix?: boolean;
-}
-export interface CallExpressionNode extends BaseNode {
-    readonly type: 'callExpression';
-    readonly callee: Expr;
-    readonly arguments: Expr[];
-    readonly isConstructor?: boolean;
-    readonly closestTo?: Expr;
-}
-export interface MemberExpressionNode extends BaseNode {
-    readonly type: 'memberExpression';
-    readonly object: Expr;
-    readonly property: Expr;
-    readonly computed: boolean;
-}
-export interface PossessiveExpressionNode extends BaseNode {
-    readonly type: 'possessiveExpression';
-    readonly object: Expr;
-    readonly property: Expr;
-}
-export interface PropertyOfExpressionNode extends BaseNode {
-    readonly type: 'propertyOfExpression';
-    readonly property: Expr;
-    readonly target: Expr;
-}
-export interface ArrayLiteralNode extends BaseNode {
-    readonly type: 'arrayLiteral';
-    readonly elements: Expr[];
-}
-export interface ObjectLiteralNode extends BaseNode {
-    readonly type: 'objectLiteral';
-    readonly properties: ReadonlyArray<{
-        readonly key: Expr & {
-            readonly valueType?: string;
-        };
-        readonly value: Expr;
-    }>;
-}
-export interface TemplateLiteralNode extends BaseNode {
-    readonly type: 'templateLiteral';
-    readonly value: string;
-}
-export interface AsExpressionNode extends BaseNode {
-    readonly type: 'asExpression';
-    readonly expression: Expr;
-    readonly targetType: Expr | string;
-}
-export interface BetweenExpressionNode extends BaseNode {
-    readonly type: 'betweenExpression';
-    readonly value: Expr;
-    readonly min: Expr;
-    readonly max: Expr;
-    readonly negated?: boolean;
-    readonly ignoringCase?: boolean;
-}
-export interface TypeCheckExpressionNode extends BaseNode {
-    readonly type: 'typeCheckExpression';
-    readonly value: Expr;
-    readonly typeName: string;
-    readonly nullOk?: boolean;
-    readonly negated?: boolean;
-}
-export interface CollectionExpressionNode extends BaseNode {
-    readonly type: 'collectionExpression';
-    readonly operator: string;
-    readonly collection: Expr;
-    readonly right: Expr;
-    readonly order?: 'asc' | 'desc';
-}
-export interface ConditionalExpressionNode extends BaseNode {
-    readonly type: 'conditionalExpression';
-    readonly test: Expr;
-    readonly consequent: Expr;
-    readonly alternate?: Expr;
-}
-export interface StringPostfixNode extends BaseNode {
-    readonly type: 'stringPostfix';
-    readonly expression: Expr;
-    readonly unit: string;
-}
-export interface BlockLiteralNode extends BaseNode {
-    readonly type: 'blockLiteral';
-    readonly parameters: string[];
-    readonly body: Expr;
-}
-export interface FunctionCallNode extends BaseNode {
-    readonly type: 'functionCall';
-    readonly name: string;
-    readonly args: Expr[];
-}
-export interface PropertyAccessNode extends BaseNode {
-    readonly type: 'propertyAccess';
-    readonly object: Expr;
-    readonly property: string | {
-        readonly name: string;
-    };
-}
-export interface ContextReferenceNode extends BaseNode {
-    readonly type: 'contextReference';
-    readonly contextType: string;
-}
-export interface GenericExpressionNode extends BaseNode {
-    readonly type: 'expression';
-    readonly value?: unknown;
-    readonly operator?: string;
-    readonly operands?: Expr[];
-}
-export interface CommandNode<K extends SlottedCommandName = SlottedCommandName> extends BaseNode {
-    readonly type: 'command';
-    readonly name: string;
-    readonly args: Expr[];
-    readonly isBlocking: boolean;
-    readonly body?: Stmt[];
-    readonly modifiers?: Partial<Record<SlotKey<K>, Expr>>;
-    readonly implicitTarget?: Expr;
-    readonly originalCommand?: string;
-    readonly semanticRoles?: Record<string, Expr>;
-    readonly partial?: boolean;
-}
-export interface BlockNode extends BaseNode {
-    readonly type: 'block';
-    readonly commands: Stmt[];
-}
-export interface EventHandlerNode extends BaseNode {
-    readonly type: 'eventHandler';
-    readonly event: string;
-    readonly commands: Stmt[];
-    readonly events?: string[];
-    readonly condition?: Expr;
-    readonly target?: string;
-    readonly targetExpression?: Expr;
-    readonly selector?: string;
-    readonly args?: string[];
-    readonly attributeName?: string;
-    readonly watchTarget?: Expr;
-    readonly customEventSource?: string;
-    readonly errorSymbol?: string;
-    readonly errorHandler?: Stmt[];
-    readonly finallyHandler?: Stmt[];
-    readonly modifiers?: {
-        readonly once?: boolean;
-        readonly prevent?: boolean;
-        readonly stop?: boolean;
-        readonly debounce?: number;
-        readonly throttle?: number;
-    };
-}
-export interface BehaviorNode extends BaseNode {
-    readonly type: 'behavior';
-    readonly name: string;
-    readonly parameters: string[];
-    readonly eventHandlers: EventHandlerNode[];
-    readonly initBlock?: Stmt;
-}
-export interface DefNode extends BaseNode {
-    readonly type: 'def';
-    readonly name: string;
-    readonly params: string[];
-    readonly body: Stmt[];
-    readonly errorSymbol?: string;
-    readonly errorHandler?: Stmt[];
-    readonly finallyHandler?: Stmt[];
-}
-export interface InitBlockNode extends BaseNode {
-    readonly type: 'initBlock';
-    readonly commands: Stmt[];
-}
-export interface CommandSequenceNode extends BaseNode {
-    readonly type: 'CommandSequence';
-    readonly commands: Stmt[];
-}
-export interface ProgramNode extends BaseNode {
-    readonly type: 'Program';
-    readonly statements: Stmt[];
-}
-export interface ErrorNode extends BaseNode {
-    readonly type: 'error';
-    readonly message?: string;
-}
-export interface PluginNode extends BaseNode {
-    readonly type: string;
-    readonly payload?: unknown;
-}
-export type Expr = LiteralNode | StringNode | IdentifierNode | SelectorNode | AttributeAccessNode | CssPropertyNode | BinaryExpressionNode | UnaryExpressionNode | CallExpressionNode | MemberExpressionNode | PossessiveExpressionNode | PropertyOfExpressionNode | ArrayLiteralNode | ObjectLiteralNode | TemplateLiteralNode | AsExpressionNode | BetweenExpressionNode | TypeCheckExpressionNode | CollectionExpressionNode | ConditionalExpressionNode | StringPostfixNode | BlockLiteralNode | FunctionCallNode | PropertyAccessNode | ContextReferenceNode | GenericExpressionNode;
-export type Stmt = CommandNode | BlockNode | EventHandlerNode | BehaviorNode | DefNode | InitBlockNode | CommandSequenceNode | ProgramNode | ErrorNode;
-export type SyntaxNode = Expr | Stmt;
-export type SyntaxKind = SyntaxNode['type'];
-//# sourceMappingURL=nodes.d.ts.map

package/dist/ast-utils/interchange/from-core.d.ts

@@ -1,12 +0,0 @@
-import type { InterchangeNode } from './types';
-interface CoreNode {
-    type: string;
-    [key: string]: unknown;
-}
-export type RoleInferrer = (name: string, args: readonly InterchangeNode[], modifiers: Readonly<Record<string, unknown>> | undefined, target: InterchangeNode | undefined) => Readonly<Record<string, InterchangeNode>> | null;
-export interface FromCoreOptions {
-    readonly inferRoles?: RoleInferrer;
-}
-export declare function fromCoreAST(node: CoreNode, options?: FromCoreOptions): InterchangeNode;
-export {};
-//# sourceMappingURL=from-core.d.ts.map

package/dist/ast-utils/interchange/to-core.d.ts

@@ -1,8 +0,0 @@
-import type { InterchangeNode } from './types';
-interface CoreNode {
-    type: string;
-    [key: string]: unknown;
-}
-export declare function toCoreAST(node: InterchangeNode): CoreNode;
-export {};
-//# sourceMappingURL=to-core.d.ts.map

package/dist/behaviors/boosted.d.ts

@@ -1,29 +0,0 @@
-import type { SwapStrategy } from '../commands/dom/swap';
-export interface BoostedConfig {
-    container: HTMLElement;
-    target?: string | HTMLElement;
-    linkSelector?: string;
-    formSelector?: string;
-    boostForms?: boolean;
-    strategy?: SwapStrategy;
-    pushUrl?: boolean;
-    useViewTransition?: boolean;
-    fetchOptions?: RequestInit;
-    onBeforeFetch?: (url: string, method: string) => void | boolean | Promise<void | boolean>;
-    onAfterSwap?: (url: string, content: string) => void | Promise<void>;
-    onError?: (error: Error, url: string) => void;
-}
-export interface BoostedInstance {
-    destroy: () => void;
-    config: BoostedConfig;
-    boost: (url: string, method?: string, body?: FormData | null) => Promise<void>;
-}
-export declare function createBoosted(config: BoostedConfig): BoostedInstance;
-export declare const BoostedBehavior: {
-    name: string;
-    init(element: HTMLElement, params?: Record<string, unknown>): BoostedInstance;
-    destroy(instance: BoostedInstance): void;
-};
-export declare function registerBoosted(registry: Map<string, unknown> | any): void;
-export declare const boostedHyperscript = "\nbehavior Boosted(target, pushHistory)\n  init\n    if no target then set target to document.body end\n    if no pushHistory then set pushHistory to true end\n  end\n\n  on click from <a[href]/> in me\n    -- Skip if modifier keys pressed\n    if event.metaKey or event.ctrlKey or event.shiftKey or event.altKey then exit end\n\n    -- Skip external links\n    set href to the @href of the target\n    if href starts with 'http' and not (href starts with location.origin) then exit end\n\n    -- Skip links with target attribute\n    if the target has @target then exit end\n\n    halt the event\n    add .hx-swapping to target\n    fetch href as html\n    swap target with it\n    remove .hx-swapping from target\n    if pushHistory then push url href end\n  end\nend\n";
-//# sourceMappingURL=boosted.d.ts.map

package/dist/behaviors/history-swap.d.ts

@@ -1,24 +0,0 @@
-import type { SwapStrategy } from '../commands/dom/swap';
-export interface HistorySwapConfig {
-    target: string | HTMLElement;
-    strategy?: SwapStrategy;
-    useViewTransition?: boolean;
-    fetchOptions?: RequestInit;
-    transformUrl?: (url: string) => string;
-    onBeforeFetch?: (url: string) => void | Promise<void>;
-    onAfterSwap?: (url: string, content: string) => void | Promise<void>;
-    onError?: (error: Error, url: string) => void;
-}
-export interface HistorySwapInstance {
-    destroy: () => void;
-    config: HistorySwapConfig;
-}
-export declare function createHistorySwap(config: HistorySwapConfig): HistorySwapInstance;
-export declare const HistorySwapBehavior: {
-    name: string;
-    init(element: HTMLElement, params?: Record<string, unknown>): HistorySwapInstance;
-    destroy(instance: HistorySwapInstance): void;
-};
-export declare function registerHistorySwap(registry: Map<string, unknown> | any): void;
-export declare const historySwapHyperscript = "\nbehavior HistorySwap(target, strategy)\n  init\n    if no target then set target to me end\n    if no strategy then set strategy to 'morph' end\n  end\n\n  on popstate from window\n    add .hx-swapping to target\n    fetch location.href as html\n    if strategy is 'morph' then\n      swap target with it\n    else if strategy is 'innerHTML' then\n      swap innerHTML of target with it\n    else\n      swap target with it\n    end\n    remove .hx-swapping from target\n  end\nend\n";
-//# sourceMappingURL=history-swap.d.ts.map