aura-glass
Version:
A comprehensive glassmorphism design system for React applications with 142+ production-ready components
174 lines • 6.33 kB
TypeScript
/**
* AuraGlass Quantum States System
* Probabilistic UI states that collapse into deterministic visuals based on user interaction
* Part of Next-Wave Systems (10/10) - Meta-Systems Framework
*/
import React from "react";
interface QuantumMeasurement<T = any> {
stateId: string;
measuredValue: T;
probability: number;
timestamp: number;
observer: string;
causedCollapse: boolean;
}
interface QuantumEntanglement {
state1: string;
state2: string;
strength: number;
correlationType: "positive" | "negative" | "complex";
created: number;
lastInteraction: number;
}
declare class ComplexNumber {
real: number;
imaginary: number;
constructor(real?: number, imaginary?: number);
static fromPolar(magnitude: number, phase: number): ComplexNumber;
magnitude(): number;
phase(): number;
multiply(other: ComplexNumber): ComplexNumber;
add(other: ComplexNumber): ComplexNumber;
normalize(): ComplexNumber;
}
declare class QuantumStateVector {
private amplitudes;
private stateLabels;
constructor(states: string[]);
setAmplitude(stateIndex: number, amplitude: ComplexNumber): void;
getAmplitude(stateIndex: number): ComplexNumber;
getProbability(stateIndex: number): number;
normalize(): void;
measure(): {
stateIndex: number;
state: string;
probability: number;
};
evolve(hamiltonianMatrix: number[][], timeStep: number): void;
getSuperposition(): Array<{
state: string;
probability: number;
amplitude: ComplexNumber;
}>;
}
declare class QuantumUISystem {
private quantumStates;
private entanglements;
private measurements;
private interferenceGenerator;
private decoherenceTimer;
private hamiltonianMatrices;
constructor();
createQuantumState<T>(stateId: string, possibleStates: T[], initialProbabilities?: number[]): QuantumStateVector;
private normalizeProbabilities;
private createHamiltonianMatrix;
private startQuantumEvolution;
measureState(stateId: string, observer?: string): QuantumMeasurement | null;
private handleEntangledMeasurements;
private scheduleDecoherence;
private restoreSuperposition;
createEntanglement(state1: string, state2: string, strength?: number, type?: "positive" | "negative" | "complex"): void;
getSuperposition(stateId: string): Array<{
state: any;
probability: number;
phase: number;
}> | null;
generateInterferencePattern(width: number, height: number, time: number): number[][];
getQuantumCoherence(stateId: string): number;
getStateVector(stateId: string): QuantumStateVector | undefined;
getAllMeasurements(): QuantumMeasurement[];
getEntanglements(): QuantumEntanglement[];
cleanup(stateId: string): void;
}
export declare function GlassQuantumStatesProvider({ children, onMeasurement, onStateChange, }: {
children: React.ReactNode;
onMeasurement?: (measurement: QuantumMeasurement) => void;
onStateChange?: (stateId: string, superposition: any[]) => void;
}): import("react/jsx-runtime").JSX.Element;
export declare function useQuantumStates(): {
system: QuantumUISystem | null;
createQuantumState: <T>(stateId: string, possibleStates: T[], initialProbabilities?: number[]) => void;
measureState: (stateId: string, observer?: string) => QuantumMeasurement | null;
getSuperposition: (stateId: string) => Array<{
state: any;
probability: number;
phase: number;
}> | null;
createEntanglement: (state1: string, state2: string, strength?: number, type?: "positive" | "negative" | "complex") => void;
getCoherence: (stateId: string) => number;
};
export declare function GlassQuantumButton({ children, possibleStates, onCollapse, className, stateId, ...props }: {
children: React.ReactNode;
possibleStates: Array<{
label: string;
color: string;
action: () => void;
}>;
onCollapse?: (selectedState: any) => void;
className?: string;
stateId?: string;
} & React.ButtonHTMLAttributes<HTMLButtonElement>): import("react/jsx-runtime").JSX.Element;
export declare function QuantumInterferencePattern({ width, height, speed, visible, className, }: {
width?: number;
height?: number;
speed?: number;
visible?: boolean;
className?: string;
}): import("react/jsx-runtime").JSX.Element;
export declare function GlassQuantumEntangledPair({ children, stateId1, stateId2, possibleStates, entanglementType, entanglementStrength, className, }: {
children: [React.ReactNode, React.ReactNode];
stateId1: string;
stateId2: string;
possibleStates: any[];
entanglementType?: "positive" | "negative" | "complex";
entanglementStrength?: number;
className?: string;
}): import("react/jsx-runtime").JSX.Element;
export declare function GlassQuantumCoherenceIndicator({ stateId, className, }: {
stateId: string;
className?: string;
}): import("react/jsx-runtime").JSX.Element;
export declare function useQuantumState<T>(stateId: string, possibleStates: T[], initialProbabilities?: number[]): {
measure: (observer?: string) => any;
collapse: (targetState: T) => void;
currentMeasurement: T | null;
superposition: {
state: T;
probability: number;
phase: number;
}[];
isInSuperposition: boolean;
dominantState: {
state: T;
probability: number;
phase: number;
} | null;
};
export declare const quantumStatePresets: {
binary: {
states: boolean[];
initialProbabilities: number[];
decoherenceTime: number;
};
ternary: {
states: string[];
initialProbabilities: number[];
decoherenceTime: number;
};
emotional: {
states: string[];
initialProbabilities: number[];
decoherenceTime: number;
};
interface: {
states: string[];
initialProbabilities: number[];
decoherenceTime: number;
};
};
export declare function GlassQuantumStates({ children, className, ...props }: {
children?: React.ReactNode;
className?: string;
} & React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
export {};
//# sourceMappingURL=GlassQuantumStates.d.ts.map