@hyperfixi/core 2.3.0 → 2.4.0

package/dist/expressions/logical/index.d.ts

@@ -26,6 +26,7 @@ export declare const containsExpression: ExpressionImplementation;
 export declare const doesNotContainExpression: ExpressionImplementation;
 export declare const startsWithExpression: ExpressionImplementation;
 export declare const endsWithExpression: ExpressionImplementation;
+export declare const betweenExpression: ExpressionImplementation;
 export declare const matchesExpression: EnhancedExpressionImplementation;
 export declare const hasExpression: ExpressionImplementation;
 export declare const doesNotHaveExpression: ExpressionImplementation;
@@ -50,6 +51,7 @@ export declare const logicalExpressions: {
     readonly doesNotContain: ExpressionImplementation;
     readonly startsWith: ExpressionImplementation;
     readonly endsWith: ExpressionImplementation;
+    readonly between: ExpressionImplementation;
     readonly matches: EnhancedExpressionImplementation;
     readonly has: ExpressionImplementation;
     readonly doesNotHave: ExpressionImplementation;

package/dist/expressions/mathematical/index.d.ts

@@ -53,17 +53,28 @@ export declare class ModuloExpression implements BaseTypedExpression<number> {
     evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
     validate(input: unknown): ValidationResult;
 }
+export declare class PowerExpression implements BaseTypedExpression<number> {
+    readonly name = "power";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left ** right";
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(_context: TypedExpressionContext, input: unknown): Promise<TypedResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
 export declare function createAdditionExpression(): AdditionExpression;
 export declare function createSubtractionExpression(): SubtractionExpression;
 export declare function createMultiplicationExpression(): MultiplicationExpression;
 export declare function createDivisionExpression(): DivisionExpression;
 export declare function createModuloExpression(): ModuloExpression;
+export declare function createPowerExpression(): PowerExpression;
 export declare const mathematicalExpressions: {
     readonly addition: AdditionExpression;
     readonly subtraction: SubtractionExpression;
     readonly multiplication: MultiplicationExpression;
     readonly division: DivisionExpression;
     readonly modulo: ModuloExpression;
+    readonly power: PowerExpression;
 };
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/expressions/shared/index.d.ts

@@ -1,4 +1,4 @@
-export { toNumber, toNumberOrNull, ensureFinite, isNumeric, safeDivide, safeModulo, } from './number-utils';
+export { toNumber, toNumberOrNull, ensureFinite, isNumeric, canBeNumeric, safeDivide, safeModulo, } from './number-utils';
 export { compareValues, coerceToComparable, areStrictlyEqual, areLooselyEqual, isGreaterThan, isLessThan, isGreaterThanOrEqual, isLessThanOrEqual, type ComparisonOperator, } from './comparison-utils';
 export { validResult, invalidResult, createError, toValidationResult, validateBinaryInput, validateUnaryInput, validateNotNull, validateNumber, validateString, validateBoolean, combineValidations, } from './validation-utils';
 export { isString, isNumber, isBoolean, isObject, isFunction, isArray, isElement, isArrayLike, inferType, } from '../type-helpers';

package/dist/expressions/shared/number-utils.d.ts

@@ -1,6 +1,7 @@
 export declare function toNumber(value: unknown, context: string): number;
 export declare function toNumberOrNull(value: unknown): number | null;
 export declare function ensureFinite(num: number, operation: string): number;
+export declare function canBeNumeric(value: unknown): boolean;
 export declare function isNumeric(value: unknown): boolean;
 export declare function safeDivide(left: number, right: number, allowInfinity?: boolean): number;
 export declare function safeModulo(left: number, right: number): number;

package/dist/htmx/htmx-attribute-processor.d.ts

@@ -1,4 +1,6 @@
 import { type HtmxConfig } from './htmx-translator.js';
+import { SSEConnection, type SSEEventSourceCtor } from './sse.js';
+import { WSConnection, type WSEventSourceCtor } from './ws.js';
 export interface HtmxConfiguringEventDetail {
     config: HtmxConfig;
     element: Element;
@@ -55,8 +57,12 @@ export interface HtmxProcessorOptions {
     root?: Element;
     requestDropping?: boolean;
     fixiEvents?: boolean;
+    eventSourceCtor?: SSEEventSourceCtor;
+    wsEventSourceCtor?: WSEventSourceCtor;
 }
 declare const HTMX_ALL_ATTRS: string[];
+declare const SSE_ATTRS: string[];
+declare const WS_ATTRS: string[];
 declare const FIXI_ATTRS: string[];
 export declare class HtmxAttributeProcessor {
     private options;
@@ -64,21 +70,51 @@ export declare class HtmxAttributeProcessor {
     private processedElements;
     private executeCallback;
     private pendingRequests;
+    private sseConnections;
+    private sseConnectionsSet;
+    private wsConnections;
+    private wsConnectionsSet;
+    private wsSendListeners;
+    private onHandlerListeners;
+    private onHandlerElements;
+    private localizedAttrSet;
+    private unsubscribeVocab;
+    private swapTemplateCache;
+    private getSwapTemplate;
+    private eventSourceCtor;
+    private wsEventSourceCtor;
     private dispatchLifecycleEvent;
     constructor(options?: HtmxProcessorOptions);
     init(executeCallback: (code: string, element: Element) => Promise<void>): void;
     destroy(): void;
+    attachSSE(element: Element): SSEConnection | null;
+    getSSEConnection(element: Element): SSEConnection | null;
+    detachSSE(element: Element): void;
+    private detachSSESubtree;
+    attachWS(element: Element): WSConnection | null;
+    private wireWSSendDescendants;
+    getWSConnection(element: Element): WSConnection | null;
+    detachWS(element: Element): void;
+    private detachWSSubtree;
+    private installOnHandlers;
+    private detachOnHandlers;
+    private detachOnHandlersSubtree;
     scanForHtmxElements(root?: Element): Element[];
+    private findHxOnElements;
     collectAttributes(element: Element): HtmxConfig;
     collectFxAttributes(element: Element): HtmxConfig;
     private isFxElement;
     processElement(element: Element): void;
     processSubtree(root: Element): void;
     private startObserver;
+    private computeAttributeFilter;
+    private refreshLocalizedAttrs;
     manualProcess(element: Element): string;
     hasPendingRequest(element: Element): boolean;
     abortPendingRequest(element: Element): boolean;
 }
-export { FIXI_ATTRS, HTMX_ALL_ATTRS as HTMX_ATTRS };
+export { FIXI_ATTRS, HTMX_ALL_ATTRS as HTMX_ATTRS, SSE_ATTRS, WS_ATTRS };
 export { translateToHyperscript, type HtmxConfig } from './htmx-translator.js';
+export { SSEConnection, type SSEEventSourceCtor, type SSEEventSourceLike } from './sse.js';
+export { WSConnection, collectWSSendPayload, type WSEventSourceCtor, type WSEventSourceLike, type WSSwapEnvelope, } from './ws.js';
 //# sourceMappingURL=htmx-attribute-processor.d.ts.map

package/dist/htmx/htmx-translator.d.ts

@@ -11,7 +11,9 @@ export interface HtmxConfig {
     pushUrl?: boolean | string;
     replaceUrl?: boolean | string;
     onHandlers?: Record<string, string>;
+    hxLive?: string;
 }
+export declare function resolveHxTarget(target: string): string;
 export declare function translateToHyperscript(config: HtmxConfig, element: Element): string;
 export declare function hasHtmxAttributes(element: Element): boolean;
 export declare function hasFxAttributes(element: Element): boolean;

package/dist/htmx/i18n-hooks.d.ts

@@ -0,0 +1,15 @@
+export type AttrNamespace = 'hx' | 'sse' | 'ws';
+export interface I18nHooks {
+    nameOf(elt: Element, ns: AttrNamespace, key: string): string;
+    selectorFor(ns: AttrNamespace, key: string): string;
+    eventNameOf(elt: Element, value: string): string;
+}
+export declare function installHooks(hooks: I18nHooks): void;
+export declare function getHooks(): I18nHooks;
+export declare function resetHooks(): void;
+export declare const KEYS: {
+    readonly hx: readonly ["get", "post", "put", "patch", "delete", "target", "swap", "trigger", "confirm", "boost", "vals", "headers", "push-url", "replace-url", "on", "live"];
+    readonly sse: readonly ["connect", "swap"];
+    readonly ws: readonly ["connect", "send"];
+};
+//# sourceMappingURL=i18n-hooks.d.ts.map

package/dist/htmx/i18n-orchestrator.d.ts

@@ -0,0 +1,15 @@
+export interface HyperfixiVocab {
+    attrs?: Record<string, string>;
+    events?: Record<string, string>;
+}
+interface VocabPayload {
+    hyperfixi?: HyperfixiVocab;
+}
+export declare function onVocabUpdate(listener: () => void): () => void;
+export declare function getAllLocalizedAttrs(): string[];
+export declare function getAllHxOnPrefixes(): string[];
+export declare function register(code: string, data: VocabPayload): void;
+export declare function isLangRegistered(code: string): boolean;
+export declare function resetOrchestrator(): void;
+export {};
+//# sourceMappingURL=i18n-orchestrator.d.ts.map

package/dist/htmx/lang-resolver.d.ts

@@ -0,0 +1,3 @@
+export declare function normLang(s: string | null | undefined): string;
+export declare function langOf(elt: Element): string;
+//# sourceMappingURL=lang-resolver.d.ts.map

package/dist/htmx/sse.d.ts

@@ -0,0 +1,60 @@
+export interface SSEConnectionOptions {
+    maxAttempts?: number;
+    baseBackoffMs?: number;
+    maxBackoffMs?: number;
+    debug?: boolean;
+}
+export type SSESwapHandler = (eventName: string, data: string) => void;
+interface DispatchTarget {
+    source: Element;
+}
+export interface SSEEventSourceLike {
+    readonly readyState: number;
+    url: string;
+    close(): void;
+    addEventListener(type: string, listener: (this: SSEEventSourceLike, ev: {
+        data: string;
+        type: string;
+    }) => void): void;
+    removeEventListener(type: string, listener: (this: SSEEventSourceLike, ev: {
+        data: string;
+        type: string;
+    }) => void): void;
+    onerror: ((ev: Event) => void) | null;
+    onopen: ((ev: Event) => void) | null;
+    onmessage: ((ev: {
+        data: string;
+        type: string;
+    }) => void) | null;
+}
+export type SSEEventSourceCtor = new (url: string, init?: {
+    withCredentials?: boolean;
+}) => SSEEventSourceLike;
+export declare class SSEConnection {
+    readonly element: Element;
+    readonly url: string;
+    private readonly swapHandler;
+    private source;
+    private listeners;
+    private destroyed;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private readonly maxAttempts;
+    private readonly baseBackoffMs;
+    private readonly maxBackoffMs;
+    private readonly debug;
+    private readonly EventSourceCtor;
+    constructor(element: Element, url: string, swapHandler: SSESwapHandler, options?: SSEConnectionOptions & {
+        EventSourceCtor?: SSEEventSourceCtor;
+    });
+    listenFor(eventName: string): void;
+    detach(): void;
+    get readyState(): number;
+    private open;
+    private closeSource;
+    private scheduleReconnect;
+    private dispatch;
+}
+export declare function isSSEDispatchTarget(value: unknown): value is DispatchTarget;
+export {};
+//# sourceMappingURL=sse.d.ts.map

package/dist/htmx/ws.d.ts

@@ -0,0 +1,59 @@
+export interface WSConnectionOptions {
+    maxAttempts?: number;
+    baseBackoffMs?: number;
+    maxBackoffMs?: number;
+    debug?: boolean;
+    protocols?: string | string[];
+}
+export interface WSSwapEnvelope {
+    target: string;
+    swap?: string;
+    data: string;
+}
+export type WSSwapHandler = (envelope: WSSwapEnvelope, rawData: string) => void;
+export interface WSEventSourceLike {
+    readonly readyState: number;
+    url: string;
+    close(code?: number, reason?: string): void;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    onopen: ((ev: Event) => void) | null;
+    onmessage: ((ev: {
+        data: string;
+    }) => void) | null;
+    onerror: ((ev: Event) => void) | null;
+    onclose: ((ev: {
+        code: number;
+        reason: string;
+        wasClean: boolean;
+    }) => void) | null;
+}
+export type WSEventSourceCtor = new (url: string, protocols?: string | string[]) => WSEventSourceLike;
+export declare class WSConnection {
+    readonly element: Element;
+    readonly url: string;
+    private readonly swapHandler;
+    private socket;
+    private destroyed;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private outboundQueue;
+    private readonly maxAttempts;
+    private readonly baseBackoffMs;
+    private readonly maxBackoffMs;
+    private readonly debug;
+    private readonly protocols;
+    private readonly WSCtor;
+    constructor(element: Element, url: string, swapHandler: WSSwapHandler, options?: WSConnectionOptions & {
+        WSEventSourceCtor?: WSEventSourceCtor;
+    });
+    get readyState(): number;
+    get isDestroyed(): boolean;
+    send(payload: string | object): void;
+    detach(): void;
+    private open;
+    private closeSocket;
+    private scheduleReconnect;
+    private dispatch;
+}
+export declare function collectWSSendPayload(source: Element): Record<string, string>;
+//# sourceMappingURL=ws.d.ts.map