@hypen-space/core 0.4.2 → 0.4.3

package/dist/retry.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Retry Utility for Network Operations
+ *
+ * Provides configurable retry logic with exponential/linear backoff
+ * for handling transient failures in network operations.
+ */
+import { type Result } from "./result.js";
+/**
+ * Options for retry behavior
+ */
+export interface RetryOptions {
+    /** Maximum number of attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    delayMs?: number;
+    /** Backoff strategy (default: 'exponential') */
+    backoff?: "linear" | "exponential" | "none";
+    /** Maximum delay cap in milliseconds (default: 30000) */
+    maxDelayMs?: number;
+    /** Jitter factor 0-1 to randomize delays (default: 0.1) */
+    jitter?: number;
+    /** Callback on each retry attempt */
+    onRetry?: (attempt: number, error: Error, nextDelayMs: number) => void;
+    /** Optional predicate to determine if error is retryable */
+    shouldRetry?: (error: Error) => boolean;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Retry a function with configurable backoff
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const result = await retry(() => fetch('/api/data'));
+ *
+ * // With options
+ * const result = await retry(
+ *   () => fetch('/api/data'),
+ *   {
+ *     maxAttempts: 5,
+ *     delayMs: 2000,
+ *     backoff: 'exponential',
+ *     onRetry: (n, err) => console.log(`Attempt ${n} failed: ${err.message}`)
+ *   }
+ * );
+ * ```
+ */
+export declare function retry<T>(fn: () => T | Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Retry a function, returning a Result instead of throwing
+ *
+ * @example
+ * ```typescript
+ * const result = await retryResult(() => fetch('/api/data'));
+ * if (result.ok) {
+ *   console.log('Success:', result.value);
+ * } else {
+ *   console.error('All retries failed:', result.error);
+ * }
+ * ```
+ */
+export declare function retryResult<T>(fn: () => T | Promise<T>, options?: RetryOptions): Promise<Result<T, Error>>;
+/**
+ * Create a retryable version of a function
+ *
+ * @example
+ * ```typescript
+ * const fetchWithRetry = withRetry(
+ *   (url: string) => fetch(url),
+ *   { maxAttempts: 3 }
+ * );
+ *
+ * const response = await fetchWithRetry('/api/data');
+ * ```
+ */
+export declare function withRetry<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn | Promise<TReturn>, options?: RetryOptions): (...args: TArgs) => Promise<TReturn>;
+/**
+ * Predefined retry conditions
+ */
+export declare const RetryConditions: {
+    /**
+     * Retry on network errors (fetch failures, timeouts)
+     */
+    networkErrors: (error: Error) => boolean;
+    /**
+     * Retry on specific HTTP status codes (from fetch Response)
+     */
+    httpRetryable: (error: Error & {
+        status?: number;
+    }) => boolean;
+    /**
+     * Retry on transient WebSocket errors
+     */
+    websocketErrors: (error: Error) => boolean;
+    /**
+     * Combine multiple conditions (retry if any match)
+     */
+    any: (...conditions: Array<(error: Error) => boolean>) => (error: Error) => boolean;
+    /**
+     * Combine multiple conditions (retry if all match)
+     */
+    all: (...conditions: Array<(error: Error) => boolean>) => (error: Error) => boolean;
+};
+/**
+ * Preset configurations for common use cases
+ */
+export declare const RetryPresets: {
+    /**
+     * Aggressive retry for critical operations
+     */
+    aggressive: {
+        maxAttempts: number;
+        delayMs: number;
+        backoff: "exponential";
+        maxDelayMs: number;
+        jitter: number;
+    };
+    /**
+     * Conservative retry for non-critical operations
+     */
+    conservative: {
+        maxAttempts: number;
+        delayMs: number;
+        backoff: "linear";
+        maxDelayMs: number;
+        jitter: number;
+    };
+    /**
+     * Fast retry for local operations (short delays)
+     */
+    fast: {
+        maxAttempts: number;
+        delayMs: number;
+        backoff: "exponential";
+        maxDelayMs: number;
+        jitter: number;
+    };
+    /**
+     * WebSocket reconnection preset
+     */
+    websocket: {
+        maxAttempts: number;
+        delayMs: number;
+        backoff: "exponential";
+        maxDelayMs: number;
+        jitter: number;
+        shouldRetry: (error: Error) => boolean;
+    };
+};

package/dist/router.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Hypen Router - Declarative routing system
+ * Integrated with Hypen's reactive state management
+ */
+export type RouteMatch = {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    path: string;
+};
+export type RouteState = {
+    currentPath: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    previousPath: string | null;
+};
+export type RouteChangeCallback = (route: RouteState) => void;
+/**
+ * Hypen Router - Manages application routing with pattern matching
+ */
+export declare class HypenRouter {
+    private state;
+    private subscribers;
+    private isInitialized;
+    private isUpdating;
+    constructor();
+    /**
+     * Initialize browser history sync
+     */
+    private initializeBrowserSync;
+    /**
+     * Get path from browser URL (supports both hash and pathname)
+     */
+    private getPathFromBrowser;
+    /**
+     * Parse query string from URL
+     */
+    private parseQuery;
+    /**
+     * Navigate to a new path
+     */
+    push(path: string): void;
+    /**
+     * Replace current path without adding to history
+     */
+    replace(path: string): void;
+    /**
+     * Go back in history
+     */
+    back(): void;
+    /**
+     * Go forward in history
+     */
+    forward(): void;
+    /**
+     * Update the current path
+     */
+    private updatePath;
+    /**
+     * Get current path
+     */
+    getCurrentPath(): string;
+    /**
+     * Get current route params
+     */
+    getParams(): Record<string, string>;
+    /**
+     * Get current query params
+     */
+    getQuery(): Record<string, string>;
+    /**
+     * Get full route state snapshot
+     */
+    getState(): RouteState;
+    /**
+     * Match a pattern against a path
+     */
+    matchPath(pattern: string, path: string): RouteMatch | null;
+    /**
+     * Subscribe to route changes
+     */
+    onNavigate(callback: RouteChangeCallback): () => void;
+    /**
+     * Notify all subscribers of route change
+     */
+    private notifySubscribers;
+    /**
+     * Check if a path matches the current route
+     */
+    isActive(pattern: string): boolean;
+    /**
+     * Get a URL with query params
+     */
+    buildUrl(path: string, query?: Record<string, string>): string;
+}

package/dist/state.d.ts

@@ -0,0 +1,42 @@
+/**
+ * State management with observer pattern and diffing
+ *
+ * Uses a proxy-based approach with self-detection to avoid
+ * creating nested proxies repeatedly.
+ */
+export type StatePath = string;
+/**
+ * Represents a change in state with full path information
+ */
+export interface StateChange {
+    paths: StatePath[];
+    newValues: Record<StatePath, any>;
+}
+/**
+ * Options for state observer
+ */
+export interface StateObserverOptions {
+    onChange: (change: StateChange) => void;
+    pathPrefix?: string;
+}
+/**
+ * Create an observable state object that tracks changes
+ */
+export declare function createObservableState<T extends object>(initialState: T, options?: StateObserverOptions): T;
+/**
+ * Helper to batch multiple state updates
+ */
+export declare function batchStateUpdates<T>(state: T, fn: () => void): void;
+/**
+ * Get a snapshot of the current state
+ */
+export declare function getStateSnapshot<T>(state: T): T;
+/**
+ * Check if a value is a Hypen state proxy
+ */
+export declare function isStateProxy(value: unknown): boolean;
+/**
+ * Get the raw (unwrapped) target from a proxy
+ * Returns the value as-is if not a proxy
+ */
+export declare function unwrapProxy<T>(value: T): T;

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Core types shared across the engine and runtime.
+ *
+ * These types are intentionally decoupled from the WASM engine so that
+ * packages can import them without pulling in any WASM code.
+ */
+export type Patch = {
+    type: "create" | "setProp" | "setText" | "insert" | "move" | "remove" | "attachEvent" | "detachEvent";
+    id?: string;
+    elementType?: string;
+    props?: Record<string, any>;
+    name?: string;
+    value?: any;
+    text?: string;
+    parentId?: string;
+    beforeId?: string;
+    eventName?: string;
+};
+export type Action = {
+    name: string;
+    payload?: any;
+    sender?: string;
+};
+export type RenderCallback = (patches: Patch[]) => void;
+export type ActionHandler = (action: Action) => void | Promise<void>;
+export type ResolvedComponent = {
+    source: string;
+    path: string;
+};
+export type ComponentResolver = (componentName: string, contextPath: string | null) => ResolvedComponent | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypen-space/core",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Hypen core engine - Platform-agnostic reactive UI runtime",
   "type": "module",
   "main": "./dist/index.js",
@@ -152,6 +152,7 @@
   "scripts": {
     "build": "bun run build.ts",
     "build:types": "tsc --emitDeclarationOnly",
+    "prepublishOnly": "bun run build",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },

package/wasm-node/package.json

@@ -16,5 +16,7 @@
     "hypen_engine.d.ts"
   ],
   "main": "hypen_engine.js",
-  "types": "hypen_engine.d.ts"
-}
+  "types": "hypen_engine.d.ts",
+  "type": "commonjs",
+  "sideEffects": false
+}