@hyperfixi/core 2.0.0

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

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

package/dist/ast-utils/interchange/index.d.ts

@@ -0,0 +1,6 @@
+export type { InterchangeNode, BaseNode, EventNode, CommandNode, LiteralNode, IdentifierNode, SelectorNode, VariableNode, BinaryNode, UnaryNode, MemberNode, PossessiveNode, CallNode, IfNode, RepeatNode, ForEachNode, WhileNode, PositionalNode, EventModifiers, } from './types';
+export { fromCoreAST } from './from-core';
+export { toCoreAST } from './to-core';
+export { interchangeToLSPDiagnostics, interchangeToLSPSymbols, interchangeToLSPHover, interchangeToLSPCompletions, calculateCyclomatic, calculateCognitive, } from './lsp';
+export type { Position as LSPPosition, Range as LSPRange, Diagnostic as LSPDiagnostic, DiagnosticSeverity as LSPDiagnosticSeverity, DocumentSymbol as LSPDocumentSymbol, SymbolKind as LSPSymbolKind, CompletionItem as LSPCompletionItem, CompletionItemKind as LSPCompletionItemKind, HoverInfo as LSPHoverInfo, } from './lsp';
+//# sourceMappingURL=index.d.ts.map

package/dist/ast-utils/interchange/lsp.d.ts

@@ -0,0 +1,108 @@
+import type { InterchangeNode } from './types';
+export interface Position {
+    line: number;
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export interface Diagnostic {
+    range: Range;
+    severity?: DiagnosticSeverity;
+    code?: string | number;
+    source?: string;
+    message: string;
+}
+export declare enum DiagnosticSeverity {
+    Error = 1,
+    Warning = 2,
+    Information = 3,
+    Hint = 4
+}
+export interface DocumentSymbol {
+    name: string;
+    detail?: string;
+    kind: SymbolKind;
+    range: Range;
+    selectionRange: Range;
+    children?: DocumentSymbol[];
+}
+export declare enum SymbolKind {
+    File = 1,
+    Module = 2,
+    Namespace = 3,
+    Package = 4,
+    Class = 5,
+    Method = 6,
+    Property = 7,
+    Field = 8,
+    Constructor = 9,
+    Enum = 10,
+    Interface = 11,
+    Function = 12,
+    Variable = 13,
+    Constant = 14,
+    String = 15,
+    Number = 16,
+    Boolean = 17,
+    Array = 18,
+    Object = 19,
+    Key = 20,
+    Null = 21,
+    EnumMember = 22,
+    Struct = 23,
+    Event = 24,
+    Operator = 25,
+    TypeParameter = 26
+}
+export interface CompletionItem {
+    label: string;
+    kind?: CompletionItemKind;
+    detail?: string;
+    documentation?: string;
+    insertText?: string;
+    sortText?: string;
+}
+export declare enum CompletionItemKind {
+    Text = 1,
+    Method = 2,
+    Function = 3,
+    Constructor = 4,
+    Field = 5,
+    Variable = 6,
+    Class = 7,
+    Interface = 8,
+    Module = 9,
+    Property = 10,
+    Unit = 11,
+    Value = 12,
+    Enum = 13,
+    Keyword = 14,
+    Snippet = 15,
+    Color = 16,
+    File = 17,
+    Reference = 18,
+    Folder = 19,
+    EnumMember = 20,
+    Constant = 21,
+    Struct = 22,
+    Event = 23,
+    Operator = 24,
+    TypeParameter = 25
+}
+export interface HoverInfo {
+    contents: string;
+    range?: Range;
+}
+export declare function interchangeToLSPDiagnostics(nodes: InterchangeNode[], options?: {
+    source?: string;
+    cyclomaticThreshold?: number;
+    cognitiveThreshold?: number;
+}): Diagnostic[];
+export declare function interchangeToLSPSymbols(nodes: InterchangeNode[]): DocumentSymbol[];
+export declare function interchangeToLSPHover(nodes: InterchangeNode[], position: Position): HoverInfo | null;
+export declare function interchangeToLSPCompletions(nodes: InterchangeNode[], position: Position): CompletionItem[];
+export declare function calculateCyclomatic(node: InterchangeNode): number;
+export declare function calculateCognitive(node: InterchangeNode): number;
+//# sourceMappingURL=lsp.d.ts.map

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

@@ -0,0 +1,8 @@
+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/ast-utils/interchange/types.d.ts

@@ -0,0 +1,113 @@
+export type InterchangeNode = EventNode | CommandNode | LiteralNode | IdentifierNode | SelectorNode | VariableNode | BinaryNode | UnaryNode | MemberNode | PossessiveNode | CallNode | IfNode | RepeatNode | ForEachNode | WhileNode | PositionalNode;
+export interface BaseNode {
+    readonly type: string;
+    readonly start?: number;
+    readonly end?: number;
+    readonly line?: number;
+    readonly column?: number;
+}
+export interface LiteralNode extends BaseNode {
+    readonly type: 'literal';
+    readonly value: string | number | boolean | null;
+}
+export interface IdentifierNode extends BaseNode {
+    readonly type: 'identifier';
+    readonly value: string;
+    readonly name?: string;
+}
+export interface SelectorNode extends BaseNode {
+    readonly type: 'selector';
+    readonly value: string;
+}
+export interface VariableNode extends BaseNode {
+    readonly type: 'variable';
+    readonly name: string;
+    readonly scope: 'local' | 'global' | 'element';
+}
+export interface BinaryNode extends BaseNode {
+    readonly type: 'binary';
+    readonly operator: string;
+    readonly left: InterchangeNode;
+    readonly right: InterchangeNode;
+}
+export interface UnaryNode extends BaseNode {
+    readonly type: 'unary';
+    readonly operator: string;
+    readonly operand: InterchangeNode;
+}
+export interface MemberNode extends BaseNode {
+    readonly type: 'member';
+    readonly object: InterchangeNode;
+    readonly property: string | InterchangeNode;
+    readonly computed?: boolean;
+}
+export interface PossessiveNode extends BaseNode {
+    readonly type: 'possessive';
+    readonly object: InterchangeNode;
+    readonly property: string;
+}
+export interface CallNode extends BaseNode {
+    readonly type: 'call';
+    readonly callee: InterchangeNode;
+    readonly args?: InterchangeNode[];
+}
+export interface PositionalNode extends BaseNode {
+    readonly type: 'positional';
+    readonly position: 'first' | 'last' | 'next' | 'previous' | 'closest' | 'parent' | 'random';
+    readonly target?: InterchangeNode;
+}
+export interface CommandNode extends BaseNode {
+    readonly type: 'command';
+    readonly name: string;
+    readonly args?: InterchangeNode[];
+    readonly target?: InterchangeNode;
+    readonly modifiers?: Record<string, unknown>;
+    readonly roles?: Readonly<Record<string, InterchangeNode>>;
+}
+export interface EventNode extends BaseNode {
+    readonly type: 'event';
+    readonly event: string;
+    readonly modifiers?: EventModifiers;
+    readonly body?: InterchangeNode[];
+    readonly target?: InterchangeNode;
+}
+export interface IfNode extends BaseNode {
+    readonly type: 'if';
+    readonly condition: InterchangeNode;
+    readonly thenBranch: InterchangeNode[];
+    readonly elseBranch?: InterchangeNode[];
+    readonly elseIfBranches?: ReadonlyArray<{
+        readonly condition: InterchangeNode;
+        readonly body: InterchangeNode[];
+    }>;
+}
+export interface RepeatNode extends BaseNode {
+    readonly type: 'repeat';
+    readonly count?: number | InterchangeNode;
+    readonly whileCondition?: InterchangeNode;
+    readonly untilEvent?: string;
+    readonly body: InterchangeNode[];
+}
+export interface ForEachNode extends BaseNode {
+    readonly type: 'foreach';
+    readonly itemName: string;
+    readonly indexName?: string;
+    readonly collection: InterchangeNode;
+    readonly body: InterchangeNode[];
+}
+export interface WhileNode extends BaseNode {
+    readonly type: 'while';
+    readonly condition: InterchangeNode;
+    readonly body: InterchangeNode[];
+}
+export interface EventModifiers {
+    readonly prevent?: boolean;
+    readonly stop?: boolean;
+    readonly once?: boolean;
+    readonly passive?: boolean;
+    readonly capture?: boolean;
+    readonly debounce?: number;
+    readonly throttle?: number;
+    readonly from?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ast-utils/query.d.ts

@@ -0,0 +1,25 @@
+import type { ASTNode, QueryMatch } from './types.js';
+interface AttributeSelector {
+    name: string;
+    operator: '=' | '!=' | '^=' | '$=' | '*=' | '|=' | '~=' | 'exists';
+    value: any;
+}
+interface PseudoSelector {
+    name: string;
+    argument: string | null;
+}
+interface ParsedSelector {
+    type: string | null;
+    attributes: AttributeSelector[];
+    pseudos: PseudoSelector[];
+    combinator: {
+        type: '>' | '+' | '~' | ' ';
+        right: ParsedSelector;
+    } | null;
+}
+export declare function query(ast: ASTNode | null, selector: string): QueryMatch | null;
+export declare function queryAll(ast: ASTNode | null, selector: string): QueryMatch[];
+export declare function parseSelector(selector: string): ParsedSelector;
+export declare function queryXPath(ast: ASTNode | null, xpath: string): ASTNode[];
+export {};
+//# sourceMappingURL=query.d.ts.map

package/dist/ast-utils/transformer.d.ts

@@ -0,0 +1,14 @@
+import type { ASTNode, VisitorHandlers, TransformOptions, OptimizationPass, VisitorContext } from './types.js';
+export declare function transform(ast: ASTNode, visitor: VisitorHandlers, options?: TransformOptions): ASTNode;
+export declare function optimize(ast: ASTNode, options?: TransformOptions): ASTNode;
+export declare function applyOptimizationPasses(ast: ASTNode, passes: OptimizationPass[]): ASTNode;
+export declare function normalize(ast: ASTNode): ASTNode;
+export declare function inlineVariables(ast: ASTNode): ASTNode;
+export declare function extractCommonExpressions(ast: ASTNode): ASTNode;
+export declare function createOptimizationPass(config: {
+    name: string;
+    description?: string;
+    transform: (node: ASTNode, context: VisitorContext) => ASTNode | ASTNode[] | null;
+    shouldRun?: (node: ASTNode) => boolean;
+}): OptimizationPass;
+//# sourceMappingURL=transformer.d.ts.map

package/dist/ast-utils/types.d.ts

@@ -0,0 +1,162 @@
+export interface ASTNode {
+    type: string;
+    start?: number;
+    end?: number;
+    line?: number;
+    column?: number;
+    [key: string]: any;
+}
+export interface VisitorContext {
+    skip(): void;
+    stop(): void;
+    replace(node: ASTNode | ASTNode[] | null): void;
+    getPath(): (string | number)[];
+    getParent(): ASTNode | null;
+    getScope(): Map<string, any>;
+    setScope(key: string, value: any): void;
+}
+export interface VisitorHandlers {
+    enter?(node: ASTNode, context: VisitorContext): void;
+    exit?(node: ASTNode, context: VisitorContext): void;
+    [nodeType: string]: ((node: any, context: VisitorContext) => void) | undefined;
+}
+export interface QueryMatch {
+    node: ASTNode;
+    path: (string | number)[];
+    matches: Record<string, any>;
+}
+export interface ComplexityMetrics {
+    cyclomatic: number;
+    cognitive: number;
+    halstead: {
+        vocabulary: number;
+        length: number;
+        difficulty: number;
+        effort: number;
+    };
+}
+export interface CodeSmell {
+    type: string;
+    severity: 'low' | 'medium' | 'high';
+    location: {
+        start?: number;
+        end?: number;
+        line?: number;
+        column?: number;
+    };
+    message: string;
+    suggestion?: string;
+}
+export interface AnalysisResult {
+    complexity: ComplexityMetrics;
+    smells: CodeSmell[];
+    patterns: PatternMatch[];
+    dependencies: DependencyGraph;
+    maintainabilityIndex: number;
+    readabilityScore: number;
+}
+export interface PatternMatch {
+    type?: string;
+    pattern: string;
+    node: ASTNode;
+    bindings: Record<string, any>;
+    confidence: number;
+    suggestion?: string;
+}
+export interface TransformOptions {
+    optimize?: boolean;
+    minify?: boolean;
+    preserveComments?: boolean;
+    batchOperations?: boolean;
+    batchSimilarOperations?: boolean;
+    redundantClassOperations?: boolean;
+}
+export interface OptimizationPass {
+    name: string;
+    transform: (node: ASTNode, context: VisitorContext) => ASTNode | ASTNode[] | null;
+    shouldRun?: ((node: ASTNode) => boolean) | undefined;
+}
+export interface DependencyGraph {
+    nodes: Set<string>;
+    edges: Map<string, Set<string>>;
+    cycles: string[][];
+}
+export interface VariableUsage {
+    name: string;
+    defined: {
+        node: ASTNode;
+        path: (string | number)[];
+    }[];
+    used: {
+        node: ASTNode;
+        path: (string | number)[];
+    }[];
+    type: 'variable' | 'function' | 'element';
+}
+export interface CodeSuggestion {
+    type: 'simplification' | 'optimization' | 'refactoring' | 'modernization' | 'batch-operations';
+    description: string;
+    suggestion: string;
+    impact: 'readability' | 'performance' | 'maintainability' | 'high' | 'medium' | 'low';
+    confidence: number;
+}
+export interface GeneratorOptions {
+    minify?: boolean;
+    indentation?: string;
+    preserveRaw?: boolean;
+    _indentLevel?: number;
+}
+export interface GeneratorResult {
+    code: string;
+    nodeCount: number;
+}
+export interface DocumentationOutput {
+    title: string;
+    description: string;
+    eventHandlers: EventHandlerDoc[];
+    behaviors: BehaviorDoc[];
+    functions: FunctionDoc[];
+    metrics: CodeMetrics;
+    generatedAt: string;
+}
+export interface EventHandlerDoc {
+    event: string;
+    selector?: string;
+    description: string;
+    commands: CommandDoc[];
+    source: string;
+}
+export interface BehaviorDoc {
+    name: string;
+    parameters: string[];
+    description: string;
+    eventHandlers: EventHandlerDoc[];
+    source: string;
+}
+export interface FunctionDoc {
+    name: string;
+    parameters: string[];
+    returns?: string | undefined;
+    description: string;
+    source: string;
+}
+export interface CommandDoc {
+    name: string;
+    description: string;
+    target?: string | undefined;
+}
+export interface CodeMetrics {
+    eventHandlerCount: number;
+    behaviorCount: number;
+    functionCount: number;
+    commandCount: number;
+    complexity: 'simple' | 'moderate' | 'complex' | 'very complex';
+    cyclomaticComplexity: number;
+}
+export interface MarkdownOptions {
+    includeSource?: boolean;
+    includeMetrics?: boolean;
+    includeToc?: boolean;
+    headingLevel?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ast-utils/visitor.d.ts

@@ -0,0 +1,40 @@
+import type { ASTNode, VisitorHandlers, VisitorContext } from './types.js';
+declare class VisitorContextImpl implements VisitorContext {
+    private _skipped;
+    private _stopped;
+    private _replaced;
+    private _hasReplacement;
+    private _path;
+    private _parent;
+    private _scope;
+    constructor(path?: (string | number)[], parent?: ASTNode | null);
+    skip(): void;
+    stop(): void;
+    replace(node: ASTNode | ASTNode[] | null): void;
+    getPath(): (string | number)[];
+    getParent(): ASTNode | null;
+    getScope(): Map<string, any>;
+    setScope(key: string, value: any): void;
+    get skipped(): boolean;
+    get stopped(): boolean;
+    get replacement(): ASTNode | ASTNode[] | null | undefined;
+    get hasReplacement(): boolean;
+    createChild(key: string | number, parent: ASTNode): VisitorContextImpl;
+}
+export declare class ASTVisitor {
+    private handlers;
+    constructor(handlers: VisitorHandlers);
+    visit(node: ASTNode, context: VisitorContextImpl): ASTNode | ASTNode[] | null;
+    private visitChildren;
+    private isASTNode;
+}
+export declare function visit(ast: ASTNode | null, visitor: ASTVisitor): ASTNode | null;
+export declare function findNodes(ast: ASTNode | null, predicate: (node: ASTNode) => boolean): ASTNode[];
+export declare function findFirst(ast: ASTNode | null, predicate: (node: ASTNode) => boolean): ASTNode | null;
+export declare function getAncestors(ast: ASTNode | null, targetNode: ASTNode): ASTNode[];
+export declare function createTypeCollector(types: string[]): ASTVisitor;
+export declare function measureDepth(ast: ASTNode): number;
+export declare function countNodeTypes(ast: ASTNode): Record<string, number>;
+export declare function createVisitorContext(): VisitorContextImpl;
+export { VisitorContextImpl };
+//# sourceMappingURL=visitor.d.ts.map

package/dist/behaviors/boosted.d.ts

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,24 @@
+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

package/dist/behaviors/index.d.ts

@@ -0,0 +1,4 @@
+export { createHistorySwap, registerHistorySwap, HistorySwapBehavior, historySwapHyperscript, type HistorySwapConfig, type HistorySwapInstance, } from './history-swap';
+export { createBoosted, registerBoosted, BoostedBehavior, boostedHyperscript, type BoostedConfig, type BoostedInstance, } from './boosted';
+export declare function registerAllBehaviors(registry: Map<string, unknown> | any): void;
+//# sourceMappingURL=index.d.ts.map