@wakastellar/ui 2.1.2 → 2.3.2

package/dist/components/waka-log-viewer/index.d.ts

@@ -0,0 +1,38 @@
+export type LogLevel = "error" | "warn" | "info" | "debug" | "trace";
+export interface LogEntry {
+    id: string;
+    timestamp: Date;
+    level: LogLevel;
+    message: string;
+    source?: string;
+    metadata?: Record<string, unknown>;
+    stackTrace?: string;
+}
+export interface WakaLogViewerProps {
+    /** Log entries to display */
+    logs: LogEntry[];
+    /** Callback when requesting more logs */
+    onLoadMore?: () => void;
+    /** Callback when clearing logs */
+    onClear?: () => void;
+    /** Callback when exporting logs */
+    onExport?: (logs: LogEntry[]) => void;
+    /** Whether streaming is active */
+    isStreaming?: boolean;
+    /** Callback to toggle streaming */
+    onToggleStreaming?: () => void;
+    /** Maximum number of logs to display */
+    maxLogs?: number;
+    /** Show timestamp */
+    showTimestamp?: boolean;
+    /** Show source */
+    showSource?: boolean;
+    /** Enable auto-scroll to bottom */
+    autoScroll?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Title */
+    title?: string;
+}
+export declare function WakaLogViewer({ logs, onLoadMore, onClear, onExport, isStreaming, onToggleStreaming, maxLogs, showTimestamp, showSource, autoScroll, className, title, }: WakaLogViewerProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultLogs: LogEntry[];

package/dist/components/waka-migration-list/index.d.ts

@@ -0,0 +1,36 @@
+export type MigrationStatus = "pending" | "applied" | "failed" | "rolled_back" | "running";
+export interface Migration {
+    id: string;
+    version: string;
+    name: string;
+    description?: string;
+    status: MigrationStatus;
+    appliedAt?: Date;
+    rolledBackAt?: Date;
+    duration?: number;
+    author?: string;
+    checksum?: string;
+    upScript?: string;
+    downScript?: string;
+    error?: string;
+}
+export interface WakaMigrationListProps {
+    /** List of migrations */
+    migrations: Migration[];
+    /** Callback when applying a migration */
+    onApply?: (migration: Migration) => void;
+    /** Callback when rolling back a migration */
+    onRollback?: (migration: Migration) => void;
+    /** Callback when viewing migration details */
+    onViewDetails?: (migration: Migration) => void;
+    /** Current database version */
+    currentVersion?: string;
+    /** Show scripts */
+    showScripts?: boolean;
+    /** Title */
+    title?: string;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaMigrationList({ migrations, onApply, onRollback, onViewDetails, currentVersion, showScripts, title, className, }: WakaMigrationListProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultMigrations: Migration[];

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-pod-card/index.d.ts

@@ -0,0 +1,73 @@
+export type PodPhase = "Running" | "Pending" | "Succeeded" | "Failed" | "Unknown";
+export type ContainerState = "running" | "waiting" | "terminated";
+export interface PodContainer {
+    name: string;
+    image: string;
+    state: ContainerState;
+    ready: boolean;
+    restartCount: number;
+    startedAt?: Date;
+    reason?: string;
+    message?: string;
+    resources?: {
+        cpu: {
+            used: number;
+            limit: number;
+        };
+        memory: {
+            used: number;
+            limit: number;
+        };
+    };
+    ports?: Array<{
+        containerPort: number;
+        protocol: string;
+    }>;
+}
+export interface PodEvent {
+    type: "Normal" | "Warning";
+    reason: string;
+    message: string;
+    timestamp: Date;
+    count?: number;
+}
+export interface PodDetails {
+    name: string;
+    namespace: string;
+    phase: PodPhase;
+    nodeName?: string;
+    podIP?: string;
+    hostIP?: string;
+    startTime?: Date;
+    containers: PodContainer[];
+    events?: PodEvent[];
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    conditions?: Array<{
+        type: string;
+        status: boolean;
+        reason?: string;
+        message?: string;
+        lastTransitionTime?: Date;
+    }>;
+}
+export interface WakaPodCardProps {
+    /** Pod details */
+    pod: PodDetails;
+    /** Callback when viewing logs */
+    onViewLogs?: (containerName: string) => void;
+    /** Callback when opening terminal */
+    onExec?: (containerName: string) => void;
+    /** Callback when deleting pod */
+    onDelete?: () => void;
+    /** Callback when restarting (deleting for recreation) */
+    onRestart?: () => void;
+    /** Show events section */
+    showEvents?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaPodCard({ pod, onViewLogs, onExec, onDelete, onRestart, showEvents, compact, className, }: WakaPodCardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultPodDetails: PodDetails;

package/dist/components/waka-query-explain/index.d.ts

@@ -0,0 +1,48 @@
+export type NodeType = "Seq Scan" | "Index Scan" | "Index Only Scan" | "Bitmap Heap Scan" | "Bitmap Index Scan" | "Nested Loop" | "Hash Join" | "Merge Join" | "Sort" | "Aggregate" | "Group" | "Limit" | "Hash" | "Materialize" | "Subquery Scan" | "CTE Scan" | "Result" | "Append" | "Unique" | "WindowAgg" | "Gather" | "Gather Merge";
+export interface ExplainNode {
+    id: string;
+    type: NodeType;
+    relation?: string;
+    alias?: string;
+    indexName?: string;
+    filter?: string;
+    joinType?: string;
+    sortKey?: string[];
+    startupCost: number;
+    totalCost: number;
+    rows: number;
+    actualRows?: number;
+    actualTime?: number;
+    loops?: number;
+    width?: number;
+    children?: ExplainNode[];
+    warnings?: string[];
+    buffers?: {
+        sharedHit?: number;
+        sharedRead?: number;
+        sharedWritten?: number;
+    };
+}
+export interface QueryPlan {
+    query: string;
+    planningTime?: number;
+    executionTime?: number;
+    totalCost: number;
+    rootNode: ExplainNode;
+}
+export interface WakaQueryExplainProps {
+    /** Query plan to display */
+    plan: QueryPlan;
+    /** Show actual vs estimated */
+    showActual?: boolean;
+    /** Show buffers info */
+    showBuffers?: boolean;
+    /** Callback when node is clicked */
+    onNodeClick?: (node: ExplainNode) => void;
+    /** Title */
+    title?: string;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaQueryExplain({ plan, showActual, showBuffers, onNodeClick, title, className, }: WakaQueryExplainProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultQueryPlan: QueryPlan;

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

@@ -0,0 +1,43 @@
+export interface SecretAccess {
+    user: string;
+    action: "read" | "write" | "rotate";
+    timestamp: Date;
+}
+export interface Secret {
+    id: string;
+    name: string;
+    description?: string;
+    type: "api-key" | "password" | "certificate" | "token" | "other";
+    value?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt?: Date;
+    rotatedAt?: Date;
+    rotationPeriod?: number;
+    lastAccessedAt?: Date;
+    lastAccessedBy?: string;
+    accessHistory?: SecretAccess[];
+    tags?: string[];
+}
+export interface WakaSecretCardProps {
+    /** Secret data */
+    secret: Secret;
+    /** Callback when rotating secret */
+    onRotate?: () => void;
+    /** Callback when deleting secret */
+    onDelete?: () => void;
+    /** Callback when copying secret */
+    onCopy?: () => void;
+    /** Callback when viewing secret value */
+    onView?: () => void;
+    /** Whether the secret value is visible */
+    isValueVisible?: boolean;
+    /** Show access history */
+    showHistory?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaSecretCard({ secret, onRotate, onDelete, onCopy, onView, isValueVisible, showHistory, compact, className, }: WakaSecretCardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultSecret: Secret;

package/dist/components/waka-security-scan-result/index.d.ts

@@ -0,0 +1,45 @@
+export type VulnerabilitySeverity = "critical" | "high" | "medium" | "low" | "info";
+export type ScanType = "sast" | "dast" | "sca" | "secret" | "container";
+export interface Vulnerability {
+    id: string;
+    title: string;
+    description: string;
+    severity: VulnerabilitySeverity;
+    type: ScanType;
+    cveId?: string;
+    cweId?: string;
+    cvssScore?: number;
+    package?: string;
+    version?: string;
+    fixedVersion?: string;
+    file?: string;
+    line?: number;
+    url?: string;
+    remediation?: string;
+}
+export interface ScanSummary {
+    critical: number;
+    high: number;
+    medium: number;
+    low: number;
+    info: number;
+    total: number;
+}
+export interface WakaSecurityScanResultProps {
+    /** List of vulnerabilities */
+    vulnerabilities: Vulnerability[];
+    /** Scan type */
+    scanType?: ScanType | "all";
+    /** Scan timestamp */
+    scannedAt?: Date;
+    /** Callback when clicking on a vulnerability */
+    onVulnerabilityClick?: (vuln: Vulnerability) => void;
+    /** Callback when viewing CVE details */
+    onViewCVE?: (cveId: string) => void;
+    /** Title */
+    title?: string;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaSecurityScanResult({ vulnerabilities, scanType, scannedAt, onVulnerabilityClick, onViewCVE, title, className, }: WakaSecurityScanResultProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultVulnerabilities: Vulnerability[];

package/dist/components/waka-service-graph/index.d.ts

@@ -0,0 +1,44 @@
+export type ServiceHealth = "healthy" | "degraded" | "unhealthy" | "unknown";
+export type ServiceType = "api" | "database" | "cache" | "queue" | "gateway" | "external";
+export interface ServiceNode {
+    id: string;
+    name: string;
+    type: ServiceType;
+    health: ServiceHealth;
+    namespace?: string;
+    version?: string;
+    replicas?: number;
+    requestsPerSec?: number;
+    errorRate?: number;
+    latencyP50?: number;
+    latencyP99?: number;
+}
+export interface ServiceConnection {
+    source: string;
+    target: string;
+    protocol?: string;
+    requestsPerSec?: number;
+    errorRate?: number;
+    latency?: number;
+}
+export interface WakaServiceGraphProps {
+    /** List of services */
+    services: ServiceNode[];
+    /** List of connections between services */
+    connections: ServiceConnection[];
+    /** Selected service ID */
+    selectedService?: string;
+    /** Callback when clicking on a service */
+    onServiceClick?: (service: ServiceNode) => void;
+    /** Callback when clicking on a connection */
+    onConnectionClick?: (connection: ServiceConnection) => void;
+    /** Callback when refreshing */
+    onRefresh?: () => void;
+    /** Show metrics on nodes */
+    showMetrics?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaServiceGraph({ services, connections, selectedService, onServiceClick, onConnectionClick, onRefresh, showMetrics, className, }: WakaServiceGraphProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultServices: ServiceNode[];
+export declare const defaultConnections: ServiceConnection[];

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-test-report/index.d.ts

@@ -0,0 +1,60 @@
+export type TestStatus = "passed" | "failed" | "skipped" | "pending";
+export interface TestCase {
+    id: string;
+    name: string;
+    status: TestStatus;
+    duration: number;
+    errorMessage?: string;
+    stackTrace?: string;
+    file?: string;
+    line?: number;
+}
+export interface TestSuite {
+    id: string;
+    name: string;
+    file?: string;
+    tests: TestCase[];
+    duration: number;
+    timestamp?: Date;
+}
+export interface CoverageReport {
+    lines: {
+        covered: number;
+        total: number;
+        percentage: number;
+    };
+    branches: {
+        covered: number;
+        total: number;
+        percentage: number;
+    };
+    functions: {
+        covered: number;
+        total: number;
+        percentage: number;
+    };
+    statements: {
+        covered: number;
+        total: number;
+        percentage: number;
+    };
+}
+export interface WakaTestReportProps {
+    /** Test suites */
+    suites: TestSuite[];
+    /** Coverage report */
+    coverage?: CoverageReport;
+    /** Title */
+    title?: string;
+    /** Callback when clicking on a test */
+    onTestClick?: (test: TestCase) => void;
+    /** Callback when viewing test file */
+    onViewFile?: (file: string, line?: number) => void;
+    /** Show only failed tests */
+    showFailedOnly?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaTestReport({ suites, coverage, title, onTestClick, onViewFile, showFailedOnly, className, }: WakaTestReportProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultTestSuites: TestSuite[];
+export declare const defaultCoverage: CoverageReport;

package/dist/components/waka-trace-viewer/index.d.ts

@@ -0,0 +1,36 @@
+export type SpanStatus = "ok" | "error" | "unset";
+export interface TraceSpan {
+    id: string;
+    traceId: string;
+    parentId?: string;
+    operationName: string;
+    serviceName: string;
+    startTime: number;
+    duration: number;
+    status: SpanStatus;
+    tags?: Record<string, string | number | boolean>;
+    logs?: Array<{
+        timestamp: number;
+        message: string;
+        level?: "info" | "warn" | "error";
+    }>;
+    children?: TraceSpan[];
+}
+export interface WakaTraceViewerProps {
+    /** Root spans of the trace */
+    spans: TraceSpan[];
+    /** Trace ID */
+    traceId?: string;
+    /** Total trace duration */
+    totalDuration?: number;
+    /** Callback when clicking on a span */
+    onSpanClick?: (span: TraceSpan) => void;
+    /** Callback when copying trace ID */
+    onCopyTraceId?: (traceId: string) => void;
+    /** Show service colors */
+    showServiceColors?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaTraceViewer({ spans, traceId, totalDuration: propTotalDuration, onSpanClick, onCopyTraceId, showServiceColors, className, }: WakaTraceViewerProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultTraceSpans: TraceSpan[];

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;