@wakastellar/ui 2.3.0 → 2.3.2

package/dist/components/index.d.ts

@@ -215,3 +215,18 @@ export { WakaFeatureFlagRow, defaultFeatureFlags, type FeatureFlag, type Feature
 export { WakaDatabaseCard, defaultDatabase, defaultDatabases, type DatabaseInfo, type DatabaseMetrics, type DatabaseType as WakaDatabaseType, type DatabaseStatus as WakaDatabaseStatus, type ReplicationRole, type WakaDatabaseCardProps, } from './waka-database-card';
 export { WakaMigrationList, defaultMigrations, type Migration, type MigrationStatus, type WakaMigrationListProps, } from './waka-migration-list';
 export { WakaQueryExplain, defaultQueryPlan, type QueryPlan, type ExplainNode, type NodeType, type WakaQueryExplainProps, } from './waka-query-explain';
+export { WakaAdProvider, useAdContext, useAdVisibility, useAdConsent, useAdSlot, AD_SIZES, type AdNetwork, type AdSize, type AdPosition, type AdSlot, type AdConfig, type AdEvent, type CustomAd, } from './waka-ad-provider';
+export { WakaAdBanner, type WakaAdBannerProps, } from './waka-ad-banner';
+export { WakaAdPlaceholder, type WakaAdPlaceholderProps, } from './waka-ad-placeholder';
+export { WakaAdFallback, type WakaAdFallbackProps, type AdFallbackVariant, } from './waka-ad-fallback';
+export { WakaSponsoredBadge, type WakaSponsoredBadgeProps, type SponsoredBadgeVariant, type SponsoredBadgeSize, } from './waka-sponsored-badge';
+export { WakaAdSidebar, type WakaAdSidebarProps, } from './waka-ad-sidebar';
+export { WakaAdInline, type WakaAdInlineProps, } from './waka-ad-inline';
+export { WakaAdInterstitial, type WakaAdInterstitialProps, } from './waka-ad-interstitial';
+export { WakaAdStickyFooter, type WakaAdStickyFooterProps, } from './waka-ad-sticky-footer';
+export { WakaSponsoredCard, type WakaSponsoredCardProps, type SponsoredCardVariant, } from './waka-sponsored-card';
+export { WakaSponsoredFeed, type WakaSponsoredFeedProps, } from './waka-sponsored-feed';
+export { WakaContentRecommendation, type WakaContentRecommendationProps, type RecommendationLayout, } from './waka-content-recommendation';
+export { WakaVideoAd, type WakaVideoAdProps, } from './waka-video-ad';
+export { WakaOutstreamVideo, type WakaOutstreamVideoProps, } from './waka-outstream-video';
+export { WakaVideoOverlay, type WakaVideoOverlayProps, type OverlayPosition, type OverlayTrigger, } from './waka-video-overlay';

package/dist/components/waka-ad-banner/index.d.ts

@@ -0,0 +1,36 @@
+import { AdSize } from '../waka-ad-provider';
+import * as React from "react";
+export interface WakaAdBannerProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Ad size preset */
+    size?: AdSize;
+    /** Custom width (when size is "custom") */
+    customWidth?: number;
+    /** Custom height (when size is "custom") */
+    customHeight?: number;
+    /** GPT ad unit path (for GPT network) */
+    adUnitPath?: string;
+    /** Targeting parameters */
+    targeting?: Record<string, string | string[]>;
+    /** Auto-refresh interval in seconds (0 = disabled) */
+    refreshInterval?: number;
+    /** Enable lazy loading */
+    lazyLoad?: boolean;
+    /** Fallback content when no ad available */
+    fallback?: React.ReactNode;
+    /** Show sponsored badge */
+    showBadge?: boolean;
+    /** Badge position */
+    badgePosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /** Custom class name */
+    className?: string;
+    /** Callback when ad loads */
+    onLoad?: () => void;
+    /** Callback when ad fails */
+    onError?: (error: Error) => void;
+    /** Callback when ad is clicked */
+    onClick?: () => void;
+}
+export declare function WakaAdBanner({ slotId, size, customWidth, customHeight, adUnitPath, targeting, refreshInterval, lazyLoad, fallback, showBadge, badgePosition, className, onLoad, onError, onClick, }: WakaAdBannerProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdBanner;

package/dist/components/waka-ad-fallback/index.d.ts

@@ -0,0 +1,33 @@
+import { AdSize } from '../waka-ad-provider';
+import * as React from "react";
+export type AdFallbackVariant = "house" | "empty" | "custom";
+export interface WakaAdFallbackProps {
+    /** Fallback variant */
+    variant?: AdFallbackVariant;
+    /** Ad size preset */
+    size?: AdSize;
+    /** Width in pixels (overrides size) */
+    width?: number;
+    /** Height in pixels (overrides size) */
+    height?: number;
+    /** Title text */
+    title?: string;
+    /** Description text */
+    description?: string;
+    /** Call to action text */
+    ctaText?: string;
+    /** Link URL */
+    ctaUrl?: string;
+    /** Image URL */
+    imageUrl?: string;
+    /** Show border */
+    showBorder?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Callback when clicked */
+    onClick?: () => void;
+    /** Custom children for variant="custom" */
+    children?: React.ReactNode;
+}
+export declare function WakaAdFallback({ variant, size, width, height, title, description, ctaText, ctaUrl, imageUrl, showBorder, className, onClick, children, }: WakaAdFallbackProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdFallback;

package/dist/components/waka-ad-inline/index.d.ts

@@ -0,0 +1,15 @@
+import { WakaAdBannerProps } from '../waka-ad-banner';
+export interface WakaAdInlineProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Ad size - defaults to responsive */
+    size?: "responsive" | "rectangle" | "leaderboard";
+    /** Alignment within container */
+    align?: "left" | "center" | "right";
+    /** Vertical margin */
+    margin?: "none" | "sm" | "md" | "lg";
+    /** Show separator lines */
+    showSeparators?: boolean;
+    /** Label above the ad */
+    label?: string;
+}
+export declare function WakaAdInline({ slotId, size, align, margin, showSeparators, label, className, ...bannerProps }: WakaAdInlineProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdInline;

package/dist/components/waka-ad-interstitial/index.d.ts

@@ -0,0 +1,26 @@
+export interface WakaAdInterstitialProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Whether the interstitial is open */
+    open: boolean;
+    /** Callback when closed */
+    onClose: () => void;
+    /** Minimum display time before close button appears (seconds) */
+    minDisplayTime?: number;
+    /** Auto-close after duration (seconds, 0 = manual close only) */
+    autoCloseAfter?: number;
+    /** GPT ad unit path */
+    adUnitPath?: string;
+    /** Show countdown timer */
+    showCountdown?: boolean;
+    /** Skip button text */
+    skipText?: string;
+    /** Custom class name */
+    className?: string;
+    /** Callback when ad loads */
+    onLoad?: () => void;
+    /** Callback when ad is clicked */
+    onClick?: () => void;
+}
+export declare function WakaAdInterstitial({ slotId, open, onClose, minDisplayTime, autoCloseAfter, adUnitPath, showCountdown, skipText, className, onLoad, onClick, }: WakaAdInterstitialProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaAdInterstitial;

package/dist/components/waka-ad-placeholder/index.d.ts

@@ -0,0 +1,17 @@
+import { AdSize } from '../waka-ad-provider';
+export interface WakaAdPlaceholderProps {
+    /** Ad size preset */
+    size?: AdSize;
+    /** Width in pixels (overrides size) */
+    width?: number;
+    /** Height in pixels (overrides size) */
+    height?: number;
+    /** Show animated skeleton */
+    animated?: boolean;
+    /** Show label text */
+    showLabel?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaAdPlaceholder({ size, width, height, animated, showLabel, className, }: WakaAdPlaceholderProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdPlaceholder;

package/dist/components/waka-ad-provider/index.d.ts

@@ -0,0 +1,103 @@
+import * as React from "react";
+export type AdNetwork = "gpt" | "custom" | "adsense";
+export type AdSize = "leaderboard" | "rectangle" | "skyscraper" | "billboard" | "mobile-banner" | "custom";
+export type AdPosition = "top" | "bottom" | "sidebar" | "inline" | "interstitial" | "sticky";
+export interface AdSlot {
+    id: string;
+    network: AdNetwork;
+    size: AdSize;
+    position: AdPosition;
+    targeting?: Record<string, string | string[]>;
+    refreshInterval?: number;
+    lazyLoad?: boolean;
+    customWidth?: number;
+    customHeight?: number;
+}
+export interface AdConfig {
+    network: AdNetwork;
+    publisherId?: string;
+    gptNetworkCode?: string;
+    gptAdUnits?: Record<string, string>;
+    customAdServer?: string;
+    customApiKey?: string;
+    enableLazyLoad?: boolean;
+    lazyLoadOffset?: number;
+    enableRefresh?: boolean;
+    defaultRefreshInterval?: number;
+    enableConsent?: boolean;
+    testMode?: boolean;
+    debugMode?: boolean;
+}
+export interface AdEvent {
+    type: "impression" | "click" | "viewable" | "error" | "loaded" | "empty";
+    slotId: string;
+    timestamp: Date;
+    data?: Record<string, unknown>;
+}
+export interface CustomAd {
+    id: string;
+    imageUrl?: string;
+    videoUrl?: string;
+    targetUrl: string;
+    title?: string;
+    description?: string;
+    sponsor?: string;
+    cta?: string;
+    trackingPixels?: string[];
+    impressionUrl?: string;
+    clickUrl?: string;
+}
+interface AdContextValue {
+    config: AdConfig;
+    isReady: boolean;
+    hasConsent: boolean | null;
+    setConsent: (consent: boolean) => void;
+    registerSlot: (slot: AdSlot) => void;
+    unregisterSlot: (slotId: string) => void;
+    refreshSlot: (slotId: string) => void;
+    refreshAll: () => void;
+    getCustomAd: (slotId: string) => Promise<CustomAd | null>;
+    trackEvent: (event: AdEvent) => void;
+    slots: Map<string, AdSlot>;
+}
+export declare const AD_SIZES: Record<AdSize, {
+    width: number;
+    height: number;
+    label: string;
+}>;
+export declare function useAdContext(): AdContextValue;
+export declare function useAdVisibility(ref: React.RefObject<HTMLElement>, threshold?: number): {
+    isVisible: boolean;
+    viewableTime: number;
+};
+export declare function useAdConsent(): {
+    hasConsent: boolean | null;
+    setConsent: (consent: boolean) => void;
+};
+export declare function useAdSlot(slot: AdSlot): {
+    refresh: () => void;
+    isReady: boolean;
+};
+interface WakaAdProviderProps {
+    children: React.ReactNode;
+    config: AdConfig;
+    onEvent?: (event: AdEvent) => void;
+}
+export declare function WakaAdProvider({ children, config, onEvent }: WakaAdProviderProps): import("react/jsx-runtime").JSX.Element;
+declare global {
+    interface Window {
+        googletag: {
+            cmd: Array<() => void>;
+            defineSlot: (adUnitPath: string, size: [number, number], divId: string) => unknown;
+            pubads: () => {
+                enableSingleRequest: () => void;
+                enableLazyLoad: (config: Record<string, unknown>) => void;
+                refresh: () => void;
+                setTargeting: (key: string, value: string | string[]) => void;
+            };
+            enableServices: () => void;
+            display: (divId: string) => void;
+        };
+    }
+}
+export default WakaAdProvider;

package/dist/components/waka-ad-sidebar/index.d.ts

@@ -0,0 +1,18 @@
+import { WakaAdBannerProps } from '../waka-ad-banner';
+export interface WakaAdSidebarProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Enable sticky behavior */
+    sticky?: boolean;
+    /** Top offset when sticky (in pixels) */
+    stickyOffset?: number;
+    /** Bottom boundary element selector */
+    boundarySelector?: string;
+    /** Gap between multiple ads */
+    gap?: number;
+    /** Additional ads to show below */
+    additionalSlots?: Array<{
+        slotId: string;
+        adUnitPath?: string;
+    }>;
+}
+export declare function WakaAdSidebar({ slotId, sticky, stickyOffset, boundarySelector, gap, additionalSlots, className, ...bannerProps }: WakaAdSidebarProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdSidebar;

package/dist/components/waka-ad-sticky-footer/index.d.ts

@@ -0,0 +1,17 @@
+import { WakaAdBannerProps } from '../waka-ad-banner';
+export interface WakaAdStickyFooterProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Allow user to dismiss */
+    dismissable?: boolean;
+    /** Show close button after delay (seconds) */
+    showCloseAfter?: number;
+    /** Animation style */
+    animation?: "slide" | "fade" | "none";
+    /** Safe area padding (for mobile notches) */
+    safeAreaPadding?: boolean;
+    /** Background blur */
+    blur?: boolean;
+    /** Container class name */
+    containerClassName?: string;
+}
+export declare function WakaAdStickyFooter({ slotId, dismissable, showCloseAfter, animation, safeAreaPadding, blur, className, containerClassName, ...bannerProps }: WakaAdStickyFooterProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaAdStickyFooter;

package/dist/components/waka-content-recommendation/index.d.ts

@@ -0,0 +1,23 @@
+export type RecommendationLayout = "grid" | "carousel" | "list";
+export interface WakaContentRecommendationProps {
+    /** Widget title */
+    title?: string;
+    /** Slot IDs for recommendations */
+    slotIds: string[];
+    /** Layout style */
+    layout?: RecommendationLayout;
+    /** Number of columns for grid layout */
+    columns?: 2 | 3 | 4;
+    /** Show navigation arrows for carousel */
+    showArrows?: boolean;
+    /** Auto-scroll carousel */
+    autoScroll?: boolean;
+    /** Auto-scroll interval (seconds) */
+    autoScrollInterval?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when item is clicked */
+    onItemClick?: (slotId: string) => void;
+}
+export declare function WakaContentRecommendation({ title, slotIds, layout, columns, showArrows, autoScroll, autoScrollInterval, className, onItemClick, }: WakaContentRecommendationProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaContentRecommendation;

package/dist/components/waka-outstream-video/index.d.ts

@@ -0,0 +1,24 @@
+export interface WakaOutstreamVideoProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Collapse when video ends or is closed */
+    collapseOnEnd?: boolean;
+    /** Collapse animation duration (ms) */
+    collapseDuration?: number;
+    /** Start muted */
+    muted?: boolean;
+    /** Show close button */
+    showClose?: boolean;
+    /** Close after seconds (0 = manual only) */
+    closeAfter?: number;
+    /** Minimum visibility to start playing (0-1) */
+    visibilityThreshold?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when video completes */
+    onComplete?: () => void;
+    /** Callback when closed */
+    onClose?: () => void;
+}
+export declare function WakaOutstreamVideo({ slotId, collapseOnEnd, collapseDuration, muted, showClose, closeAfter, visibilityThreshold, className, onComplete, onClose, }: WakaOutstreamVideoProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaOutstreamVideo;

package/dist/components/waka-sponsored-badge/index.d.ts

@@ -0,0 +1,20 @@
+export type SponsoredBadgeVariant = "default" | "subtle" | "outline" | "dark";
+export type SponsoredBadgeSize = "sm" | "md" | "lg";
+export interface WakaSponsoredBadgeProps {
+    /** Sponsor name (optional) */
+    sponsor?: string;
+    /** Badge variant */
+    variant?: SponsoredBadgeVariant;
+    /** Badge size */
+    size?: SponsoredBadgeSize;
+    /** Show info icon */
+    showIcon?: boolean;
+    /** Custom label text */
+    label?: string;
+    /** Custom class name */
+    className?: string;
+    /** Callback when info is clicked */
+    onInfoClick?: () => void;
+}
+export declare function WakaSponsoredBadge({ sponsor, variant, size, showIcon, label, className, onInfoClick, }: WakaSponsoredBadgeProps): import("react/jsx-runtime").JSX.Element;
+export default WakaSponsoredBadge;

package/dist/components/waka-sponsored-card/index.d.ts

@@ -0,0 +1,25 @@
+export type SponsoredCardVariant = "article" | "product" | "compact" | "horizontal";
+export interface WakaSponsoredCardProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Card variant */
+    variant?: SponsoredCardVariant;
+    /** GPT ad unit path */
+    adUnitPath?: string;
+    /** Show image */
+    showImage?: boolean;
+    /** Show description */
+    showDescription?: boolean;
+    /** Show CTA button */
+    showCta?: boolean;
+    /** Image aspect ratio */
+    aspectRatio?: "video" | "square" | "portrait";
+    /** Custom class name */
+    className?: string;
+    /** Callback when clicked */
+    onClick?: () => void;
+    /** Callback when loaded */
+    onLoad?: () => void;
+}
+export declare function WakaSponsoredCard({ slotId, variant, adUnitPath, showImage, showDescription, showCta, aspectRatio, className, onClick, onLoad, }: WakaSponsoredCardProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaSponsoredCard;

package/dist/components/waka-sponsored-feed/index.d.ts

@@ -0,0 +1,31 @@
+import { SponsoredCardVariant } from '../waka-sponsored-card';
+import * as React from "react";
+export interface WakaSponsoredFeedProps<T> {
+    /** Content items */
+    items: T[];
+    /** Render function for content items */
+    renderItem: (item: T, index: number) => React.ReactNode;
+    /** Ad slot IDs to inject */
+    adSlots: Array<{
+        slotId: string;
+        adUnitPath?: string;
+    }>;
+    /** Insert ad every N items */
+    adFrequency?: number;
+    /** Starting position for first ad (0-indexed) */
+    adStartPosition?: number;
+    /** Card variant for ads */
+    adVariant?: SponsoredCardVariant;
+    /** Maximum number of ads to show */
+    maxAds?: number;
+    /** Grid columns for items */
+    columns?: 1 | 2 | 3 | 4;
+    /** Gap between items */
+    gap?: "sm" | "md" | "lg";
+    /** Custom class name */
+    className?: string;
+    /** Key extractor for items */
+    keyExtractor?: (item: T, index: number) => string;
+}
+export declare function WakaSponsoredFeed<T>({ items, renderItem, adSlots, adFrequency, adStartPosition, adVariant, maxAds, columns, gap, className, keyExtractor, }: WakaSponsoredFeedProps<T>): import("react/jsx-runtime").JSX.Element;
+export default WakaSponsoredFeed;

package/dist/components/waka-video-ad/index.d.ts

@@ -0,0 +1,32 @@
+export interface WakaVideoAdProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Video width */
+    width?: number;
+    /** Video height */
+    height?: number;
+    /** Aspect ratio */
+    aspectRatio?: "16/9" | "4/3" | "1/1" | "9/16";
+    /** Autoplay when visible */
+    autoplay?: boolean;
+    /** Mute by default */
+    muted?: boolean;
+    /** Show controls */
+    showControls?: boolean;
+    /** Skip time in seconds (0 = no skip) */
+    skipAfter?: number;
+    /** Show progress bar */
+    showProgress?: boolean;
+    /** CTA overlay position */
+    ctaPosition?: "bottom" | "overlay" | "end";
+    /** Custom class name */
+    className?: string;
+    /** Callback when video completes */
+    onComplete?: () => void;
+    /** Callback when skipped */
+    onSkip?: () => void;
+    /** Callback when clicked */
+    onClick?: () => void;
+}
+export declare function WakaVideoAd({ slotId, width, height, aspectRatio, autoplay, muted, showControls, skipAfter, showProgress, ctaPosition, className, onComplete, onSkip, onClick, }: WakaVideoAdProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaVideoAd;

package/dist/components/waka-video-overlay/index.d.ts

@@ -0,0 +1,26 @@
+export type OverlayPosition = "bottom" | "top" | "corner";
+export type OverlayTrigger = "start" | "pause" | "time" | "manual";
+export interface WakaVideoOverlayProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Whether overlay is visible */
+    visible?: boolean;
+    /** Trigger for showing overlay */
+    trigger?: OverlayTrigger;
+    /** Time trigger (seconds from start) */
+    triggerTime?: number;
+    /** Position of overlay */
+    position?: OverlayPosition;
+    /** Allow dismissing */
+    dismissable?: boolean;
+    /** Auto-hide after seconds (0 = manual) */
+    hideAfter?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when dismissed */
+    onDismiss?: () => void;
+    /** Callback when clicked */
+    onClick?: () => void;
+}
+export declare function WakaVideoOverlay({ slotId, visible, trigger, triggerTime, position, dismissable, hideAfter, className, onDismiss, onClick, }: WakaVideoOverlayProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaVideoOverlay;