@sc4rfurryx/proteusjs 1.0.0 → 1.1.1

package/dist/proteus.d.ts

@@ -312,7 +312,7 @@ interface SupportInfo {
 /**
  * Check if the current environment supports ProteusJS features
  */
-declare function isSupported(): boolean;
+declare function isSupported$1(): boolean;
 
 /**
  * Core type definitions for ProteusJS
@@ -588,7 +588,7 @@ interface ContainerState {
     activeBreakpoints: string[];
     lastUpdate: number;
 }
-interface ContainerOptions {
+interface ContainerOptions$1 {
     breakpoints?: BreakpointConfig$1;
     containerType?: 'inline-size' | 'size' | 'block-size' | 'auto';
     debounceMs?: number;
@@ -610,7 +610,7 @@ declare class SmartContainer {
     private debouncedUpdate;
     private isActive;
     private liveRegion;
-    constructor(element: Element, options: ContainerOptions | undefined, observerManager: ObserverManager, memoryManager: MemoryManager);
+    constructor(element: Element, options: ContainerOptions$1 | undefined, observerManager: ObserverManager, memoryManager: MemoryManager);
     /**
      * Start observing the container
      */
@@ -1047,7 +1047,7 @@ declare class ContainerManager {
     /**
      * Create and manage a container
      */
-    container(selector: string | Element | Element[], options?: ContainerOptions): SmartContainer | SmartContainer[];
+    container(selector: string | Element | Element[], options?: ContainerOptions$1): SmartContainer | SmartContainer[];
     /**
      * Remove container management from element(s)
      */
@@ -2862,7 +2862,7 @@ declare class ProteusJS {
     /**
      * Create a container with responsive behavior
      */
-    container(selector: string | Element | Element[], options?: ContainerOptions): SmartContainer | SmartContainer[];
+    container(selector: string | Element | Element[], options?: ContainerOptions$1): SmartContainer | SmartContainer[];
     /**
      * Create fluid typography scaling
      */
@@ -2997,22 +2997,526 @@ declare class ProteusJS {
     };
 }
 
+/**
+ * @sc4rfurryx/proteusjs/transitions
+ * View Transitions API wrapper with safe fallbacks
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface TransitionOptions {
+    name?: string;
+    duration?: number;
+    onBefore?: () => void;
+    onAfter?: () => void;
+    allowInterrupt?: boolean;
+}
+interface NavigateOptions {
+    name?: string;
+    prerender?: boolean;
+}
+/**
+ * One API for animating DOM state changes and cross-document navigations
+ * using the View Transitions API with safe fallbacks.
+ */
+declare function transition(run: () => Promise<any> | any, opts?: TransitionOptions): Promise<void>;
+/**
+ * MPA-friendly navigation with view transitions when supported
+ */
+declare function navigate(url: string, opts?: NavigateOptions): Promise<void>;
+declare const _default$8: {
+    transition: typeof transition;
+    navigate: typeof navigate;
+};
+
+type index$8_NavigateOptions = NavigateOptions;
+type index$8_TransitionOptions = TransitionOptions;
+declare const index$8_navigate: typeof navigate;
+declare const index$8_transition: typeof transition;
+declare namespace index$8 {
+  export { _default$8 as default, index$8_navigate as navigate, index$8_transition as transition };
+  export type { index$8_NavigateOptions as NavigateOptions, index$8_TransitionOptions as TransitionOptions };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/scroll
+ * Scroll-driven animations with CSS Scroll-Linked Animations
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface ScrollAnimateOptions {
+    keyframes: Keyframe[];
+    range?: [string, string];
+    timeline?: {
+        axis?: 'block' | 'inline';
+        start?: string;
+        end?: string;
+    };
+    fallback?: 'io' | false;
+}
+/**
+ * Zero-boilerplate setup for CSS Scroll-Linked Animations with fallbacks
+ */
+declare function scrollAnimate(target: Element | string, opts: ScrollAnimateOptions): void;
+/**
+ * Create a scroll-triggered animation that plays once when element enters viewport
+ */
+declare function scrollTrigger(target: Element | string, keyframes: Keyframe[], options?: KeyframeAnimationOptions): void;
+/**
+ * Parallax effect using scroll-driven animations
+ */
+declare function parallax(target: Element | string, speed?: number): void;
+/**
+ * Cleanup function to remove scroll animations
+ */
+declare function cleanup$2(target: Element | string): void;
+declare const _default$7: {
+    scrollAnimate: typeof scrollAnimate;
+    scrollTrigger: typeof scrollTrigger;
+    parallax: typeof parallax;
+    cleanup: typeof cleanup$2;
+};
+
+type index$7_ScrollAnimateOptions = ScrollAnimateOptions;
+declare const index$7_parallax: typeof parallax;
+declare const index$7_scrollAnimate: typeof scrollAnimate;
+declare const index$7_scrollTrigger: typeof scrollTrigger;
+declare namespace index$7 {
+  export { cleanup$2 as cleanup, _default$7 as default, index$7_parallax as parallax, index$7_scrollAnimate as scrollAnimate, index$7_scrollTrigger as scrollTrigger };
+  export type { index$7_ScrollAnimateOptions as ScrollAnimateOptions };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/anchor
+ * CSS Anchor Positioning utilities with robust JS fallback
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface TetherOptions {
+    anchor: Element | string;
+    placement?: 'top' | 'bottom' | 'left' | 'right' | 'auto';
+    align?: 'start' | 'center' | 'end';
+    offset?: number;
+    strategy?: 'absolute' | 'fixed';
+}
+interface TetherController {
+    update(): void;
+    destroy(): void;
+}
+/**
+ * Declarative tethers (tooltips, callouts) via CSS Anchor Positioning when available;
+ * robust JS fallback with flip/collision detection
+ */
+declare function tether(floating: Element | string, opts: TetherOptions): TetherController;
+declare const _default$6: {
+    tether: typeof tether;
+};
+
+type index$6_TetherController = TetherController;
+type index$6_TetherOptions = TetherOptions;
+declare const index$6_tether: typeof tether;
+declare namespace index$6 {
+  export { _default$6 as default, index$6_tether as tether };
+  export type { index$6_TetherController as TetherController, index$6_TetherOptions as TetherOptions };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/popover
+ * HTML Popover API wrapper with robust focus/inert handling
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface PopoverOptions {
+    type?: 'menu' | 'dialog' | 'tooltip';
+    trapFocus?: boolean;
+    restoreFocus?: boolean;
+    closeOnEscape?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+}
+interface PopoverController {
+    open(): void;
+    close(): void;
+    toggle(): void;
+    destroy(): void;
+}
+/**
+ * Unified API for menus, tooltips, and dialogs using the native Popover API
+ * with robust focus/inert handling
+ */
+declare function attach(trigger: Element | string, panel: Element | string, opts?: PopoverOptions): PopoverController;
+declare const _default$5: {
+    attach: typeof attach;
+};
+
+type index$5_PopoverController = PopoverController;
+type index$5_PopoverOptions = PopoverOptions;
+declare const index$5_attach: typeof attach;
+declare namespace index$5 {
+  export { index$5_attach as attach, _default$5 as default };
+  export type { index$5_PopoverController as PopoverController, index$5_PopoverOptions as PopoverOptions };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/container
+ * Container/Style Query helpers with visualization devtools
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface ContainerOptions {
+    type?: 'size' | 'style';
+    inlineSize?: boolean;
+}
+/**
+ * Sugar on native container queries with dev visualization
+ */
+declare function defineContainer(target: Element | string, name?: string, opts?: ContainerOptions): void;
+/**
+ * Helper to create container query CSS rules
+ */
+declare function createContainerQuery(containerName: string, condition: string, styles: Record<string, string>): string;
+/**
+ * Apply container query styles dynamically
+ */
+declare function applyContainerQuery(containerName: string, condition: string, styles: Record<string, string>): void;
+/**
+ * Remove container query styles
+ */
+declare function removeContainerQuery(containerName: string): void;
+/**
+ * Get container size information
+ */
+declare function getContainerSize(target: Element | string): {
+    width: number;
+    height: number;
+};
+/**
+ * Check if container queries are supported
+ */
+declare function isSupported(): boolean;
+/**
+ * Cleanup container overlays and observers
+ */
+declare function cleanup$1(target: Element | string): void;
+/**
+ * Toggle dev overlay visibility
+ */
+declare function toggleDevOverlay(visible?: boolean): void;
+declare const _default$4: {
+    defineContainer: typeof defineContainer;
+    createContainerQuery: typeof createContainerQuery;
+    applyContainerQuery: typeof applyContainerQuery;
+    removeContainerQuery: typeof removeContainerQuery;
+    getContainerSize: typeof getContainerSize;
+    isSupported: typeof isSupported;
+    cleanup: typeof cleanup$1;
+    toggleDevOverlay: typeof toggleDevOverlay;
+};
+
+type index$4_ContainerOptions = ContainerOptions;
+declare const index$4_applyContainerQuery: typeof applyContainerQuery;
+declare const index$4_createContainerQuery: typeof createContainerQuery;
+declare const index$4_defineContainer: typeof defineContainer;
+declare const index$4_getContainerSize: typeof getContainerSize;
+declare const index$4_isSupported: typeof isSupported;
+declare const index$4_removeContainerQuery: typeof removeContainerQuery;
+declare const index$4_toggleDevOverlay: typeof toggleDevOverlay;
+declare namespace index$4 {
+  export { index$4_applyContainerQuery as applyContainerQuery, cleanup$1 as cleanup, index$4_createContainerQuery as createContainerQuery, _default$4 as default, index$4_defineContainer as defineContainer, index$4_getContainerSize as getContainerSize, index$4_isSupported as isSupported, index$4_removeContainerQuery as removeContainerQuery, index$4_toggleDevOverlay as toggleDevOverlay };
+  export type { index$4_ContainerOptions as ContainerOptions };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/typography
+ * Fluid typography with CSS-first approach
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface FluidTypeOptions {
+    minViewportPx?: number;
+    maxViewportPx?: number;
+    lineHeight?: number;
+    containerUnits?: boolean;
+}
+interface FluidTypeResult {
+    css: string;
+}
+/**
+ * Generate pure-CSS clamp() rules for fluid typography
+ */
+declare function fluidType(minRem: number, maxRem: number, options?: FluidTypeOptions): FluidTypeResult;
+/**
+ * Apply fluid typography to elements
+ */
+declare function applyFluidType(selector: string, minRem: number, maxRem: number, options?: FluidTypeOptions): void;
+/**
+ * Create a complete typographic scale
+ */
+declare function createTypographicScale(baseSize?: number, ratio?: number, steps?: number, options?: FluidTypeOptions): Record<string, FluidTypeResult>;
+/**
+ * Generate CSS custom properties for a typographic scale
+ */
+declare function generateScaleCSS(scale: Record<string, FluidTypeResult>, prefix?: string): string;
+/**
+ * Optimize line height for readability
+ */
+declare function optimizeLineHeight(fontSize: number, measure?: number): number;
+/**
+ * Calculate optimal font size for container width
+ */
+declare function calculateOptimalSize(containerWidth: number, targetCharacters?: number, baseCharWidth?: number): number;
+/**
+ * Apply responsive typography to an element
+ */
+declare function makeResponsive(target: Element | string, options?: {
+    minSize?: number;
+    maxSize?: number;
+    targetCharacters?: number;
+    autoLineHeight?: boolean;
+}): void;
+/**
+ * Remove applied typography styles
+ */
+declare function cleanup(target?: Element | string): void;
+/**
+ * Check if container query units are supported
+ */
+declare function supportsContainerUnits(): boolean;
+declare const _default$3: {
+    fluidType: typeof fluidType;
+    applyFluidType: typeof applyFluidType;
+    createTypographicScale: typeof createTypographicScale;
+    generateScaleCSS: typeof generateScaleCSS;
+    optimizeLineHeight: typeof optimizeLineHeight;
+    calculateOptimalSize: typeof calculateOptimalSize;
+    makeResponsive: typeof makeResponsive;
+    cleanup: typeof cleanup;
+    supportsContainerUnits: typeof supportsContainerUnits;
+};
+
+type index$3_FluidTypeOptions = FluidTypeOptions;
+type index$3_FluidTypeResult = FluidTypeResult;
+declare const index$3_applyFluidType: typeof applyFluidType;
+declare const index$3_calculateOptimalSize: typeof calculateOptimalSize;
+declare const index$3_cleanup: typeof cleanup;
+declare const index$3_createTypographicScale: typeof createTypographicScale;
+declare const index$3_fluidType: typeof fluidType;
+declare const index$3_generateScaleCSS: typeof generateScaleCSS;
+declare const index$3_makeResponsive: typeof makeResponsive;
+declare const index$3_optimizeLineHeight: typeof optimizeLineHeight;
+declare const index$3_supportsContainerUnits: typeof supportsContainerUnits;
+declare namespace index$3 {
+  export { index$3_applyFluidType as applyFluidType, index$3_calculateOptimalSize as calculateOptimalSize, index$3_cleanup as cleanup, index$3_createTypographicScale as createTypographicScale, _default$3 as default, index$3_fluidType as fluidType, index$3_generateScaleCSS as generateScaleCSS, index$3_makeResponsive as makeResponsive, index$3_optimizeLineHeight as optimizeLineHeight, index$3_supportsContainerUnits as supportsContainerUnits };
+  export type { index$3_FluidTypeOptions as FluidTypeOptions, index$3_FluidTypeResult as FluidTypeResult };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/a11y-audit
+ * Lightweight accessibility audits for development
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface AuditOptions {
+    rules?: string[];
+    format?: 'console' | 'json';
+}
+interface AuditViolation {
+    id: string;
+    impact: 'minor' | 'moderate' | 'serious' | 'critical';
+    nodes: number;
+    help: string;
+}
+interface AuditReport {
+    violations: AuditViolation[];
+    passes: number;
+    timestamp: number;
+    url: string;
+}
+declare function audit(target?: Document | Element, options?: AuditOptions): Promise<AuditReport>;
+declare const _default$2: {
+    audit: typeof audit;
+};
+
+type index$2_AuditOptions = AuditOptions;
+type index$2_AuditReport = AuditReport;
+type index$2_AuditViolation = AuditViolation;
+declare const index$2_audit: typeof audit;
+declare namespace index$2 {
+  export { index$2_audit as audit, _default$2 as default };
+  export type { index$2_AuditOptions as AuditOptions, index$2_AuditReport as AuditReport, index$2_AuditViolation as AuditViolation };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/a11y-primitives
+ * Lightweight accessibility patterns
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface Controller {
+    destroy(): void;
+}
+interface DialogOptions {
+    modal?: boolean;
+    restoreFocus?: boolean;
+}
+interface TooltipOptions {
+    delay?: number;
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+}
+interface FocusTrapController {
+    activate(): void;
+    deactivate(): void;
+}
+declare function dialog(root: Element | string, opts?: DialogOptions): Controller;
+declare function tooltip(trigger: Element, content: Element, opts?: TooltipOptions): Controller;
+declare function focusTrap(container: Element): FocusTrapController;
+declare function menu(container: Element): Controller;
+declare const _default$1: {
+    dialog: typeof dialog;
+    tooltip: typeof tooltip;
+    focusTrap: typeof focusTrap;
+    menu: typeof menu;
+};
+
+type index$1_Controller = Controller;
+type index$1_DialogOptions = DialogOptions;
+type index$1_FocusTrapController = FocusTrapController;
+type index$1_TooltipOptions = TooltipOptions;
+declare const index$1_dialog: typeof dialog;
+declare const index$1_focusTrap: typeof focusTrap;
+declare const index$1_menu: typeof menu;
+declare const index$1_tooltip: typeof tooltip;
+declare namespace index$1 {
+  export { _default$1 as default, index$1_dialog as dialog, index$1_focusTrap as focusTrap, index$1_menu as menu, index$1_tooltip as tooltip };
+  export type { index$1_Controller as Controller, index$1_DialogOptions as DialogOptions, index$1_FocusTrapController as FocusTrapController, index$1_TooltipOptions as TooltipOptions };
+}
+
+/**
+ * @sc4rfurryx/proteusjs/perf
+ * Performance guardrails and CWV-friendly patterns
+ *
+ * @version 1.1.0
+ * @author sc4rfurry
+ * @license MIT
+ */
+interface SpeculationOptions {
+    prerender?: string[];
+    prefetch?: string[];
+    sameOriginOnly?: boolean;
+}
+interface ContentVisibilityOptions {
+    containIntrinsicSize?: string;
+}
+/**
+ * Apply content-visibility for performance optimization
+ */
+declare function contentVisibility(selector: string | Element, mode?: 'auto' | 'hidden', opts?: ContentVisibilityOptions): void;
+/**
+ * Set fetch priority for resources
+ */
+declare function fetchPriority(selector: string | Element, priority: 'high' | 'low' | 'auto'): void;
+/**
+ * Set up speculation rules for prerendering and prefetching
+ */
+declare function speculate(opts: SpeculationOptions): void;
+/**
+ * Yield to browser using scheduler.yield or postTask when available
+ */
+declare function yieldToBrowser(): Promise<void>;
+/**
+ * Optimize images with loading and decoding hints
+ */
+declare function optimizeImages(selector?: string | Element): void;
+/**
+ * Preload critical resources
+ */
+declare function preloadCritical(resources: Array<{
+    href: string;
+    as: string;
+    type?: string;
+}>): void;
+/**
+ * Measure and report Core Web Vitals
+ */
+declare function measureCWV(): Promise<{
+    lcp?: number;
+    fid?: number;
+    cls?: number;
+}>;
+declare const boost: {
+    contentVisibility: typeof contentVisibility;
+    fetchPriority: typeof fetchPriority;
+    speculate: typeof speculate;
+    yieldToBrowser: typeof yieldToBrowser;
+    optimizeImages: typeof optimizeImages;
+    preloadCritical: typeof preloadCritical;
+    measureCWV: typeof measureCWV;
+};
+declare const _default: {
+    contentVisibility: typeof contentVisibility;
+    fetchPriority: typeof fetchPriority;
+    speculate: typeof speculate;
+    yieldToBrowser: typeof yieldToBrowser;
+    optimizeImages: typeof optimizeImages;
+    preloadCritical: typeof preloadCritical;
+    measureCWV: typeof measureCWV;
+    boost: {
+        contentVisibility: typeof contentVisibility;
+        fetchPriority: typeof fetchPriority;
+        speculate: typeof speculate;
+        yieldToBrowser: typeof yieldToBrowser;
+        optimizeImages: typeof optimizeImages;
+        preloadCritical: typeof preloadCritical;
+        measureCWV: typeof measureCWV;
+    };
+};
+
+type index_ContentVisibilityOptions = ContentVisibilityOptions;
+type index_SpeculationOptions = SpeculationOptions;
+declare const index_boost: typeof boost;
+declare const index_contentVisibility: typeof contentVisibility;
+declare const index_fetchPriority: typeof fetchPriority;
+declare const index_measureCWV: typeof measureCWV;
+declare const index_optimizeImages: typeof optimizeImages;
+declare const index_preloadCritical: typeof preloadCritical;
+declare const index_speculate: typeof speculate;
+declare const index_yieldToBrowser: typeof yieldToBrowser;
+declare namespace index {
+  export { index_boost as boost, index_contentVisibility as contentVisibility, _default as default, index_fetchPriority as fetchPriority, index_measureCWV as measureCWV, index_optimizeImages as optimizeImages, index_preloadCritical as preloadCritical, index_speculate as speculate, index_yieldToBrowser as yieldToBrowser };
+  export type { index_ContentVisibilityOptions as ContentVisibilityOptions, index_SpeculationOptions as SpeculationOptions };
+}
+
 /**
  * Version utilities for ProteusJS
  */
-declare const version = "1.0.0";
+declare const version = "1.1.0";
 
 /**
- * ProteusJS - Dynamic Responsive Design Library
+ * ProteusJS - Native-first Web Development Primitives
  * Shape-shifting responsive design that adapts like the sea god himself
  *
- * @version 1.0.0
- * @author ProteusJS Team
+ * @version 1.1.0
+ * @author sc4rfurry
  * @license MIT
  */
 
-declare const VERSION = "1.0.0";
+declare const VERSION = "1.1.0";
 declare const LIBRARY_NAME = "ProteusJS";
 
-export { LIBRARY_NAME, ProteusJS, VERSION, ProteusJS as default, isSupported, version };
-export type { AccessibilityConfig$1 as AccessibilityConfig, AnimationConfig, BreakpointConfig$1 as BreakpointConfig, ContainerConfig, LayoutConfig, PerformanceConfig, ProteusConfig, ProteusPlugin, TypographyConfig };
+export { LIBRARY_NAME, ProteusJS, VERSION, index$2 as a11yAudit, index$1 as a11yPrimitives, index$6 as anchor, index$4 as container, ProteusJS as default, isSupported$1 as isSupported, index as perf, index$5 as popover, index$7 as scroll, index$8 as transitions, index$3 as typography, version };
+export type { AccessibilityConfig$1 as AccessibilityConfig, AnimationConfig, AuditOptions, AuditReport, AuditViolation, BreakpointConfig$1 as BreakpointConfig, ContainerConfig, ContainerOptions, ContentVisibilityOptions, Controller, DialogOptions, FluidTypeOptions, FluidTypeResult, FocusTrapController, LayoutConfig, NavigateOptions, PerformanceConfig, PopoverController, PopoverOptions, ProteusConfig, ProteusPlugin, ScrollAnimateOptions, SpeculationOptions, TetherController, TetherOptions, TooltipOptions, TransitionOptions, TypographyConfig };