nucleus-core-ts 0.8.7 → 0.8.8

package/dist/client.js

@@ -1 +1 @@
-function _0xe3a3(){var _0x15da44=['mte4nJyYAevPtwnk','ndCZnZbrs3LKyMi','mZy5mJb0A0vyBKS','mtiWmZmXmLnpyKjoDW','odi5og1JB0r3rW','oefXBNvhsG','mtvfAhzfBum','nZKWmtG4u21wBw1q','nJy3odG4sNbSCwvs'];_0xe3a3=function(){return _0x15da44;};return _0xe3a3();}(function(_0x28c8cd,_0x742156){var _0x336384=_0x47e0,_0x568de6=_0x28c8cd();while(!![]){try{var _0x51b633=-parseInt(_0x336384(0x16d))/0x1+parseInt(_0x336384(0x16a))/0x2+-parseInt(_0x336384(0x16b))/0x3*(parseInt(_0x336384(0x170))/0x4)+-parseInt(_0x336384(0x171))/0x5*(-parseInt(_0x336384(0x16c))/0x6)+parseInt(_0x336384(0x172))/0x7+-parseInt(_0x336384(0x16e))/0x8+parseInt(_0x336384(0x16f))/0x9;if(_0x51b633===_0x742156)break;else _0x568de6['push'](_0x568de6['shift']());}catch(_0x29c13d){_0x568de6['push'](_0x568de6['shift']());}}}(_0xe3a3,0x320c1));function _0x47e0(_0x4bf846,_0x36becd){_0x4bf846=_0x4bf846-0x16a;var _0xe3a386=_0xe3a3();var _0x47e0a0=_0xe3a386[_0x4bf846];if(_0x47e0['xyJARa']===undefined){var _0x752d02=function(_0x5828af){var _0x28b0c3='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0xb2246e='',_0x2b6516='';for(var _0x56862d=0x0,_0x267d1c,_0x327160,_0x3cd0f2=0x0;_0x327160=_0x5828af['charAt'](_0x3cd0f2++);~_0x327160&&(_0x267d1c=_0x56862d%0x4?_0x267d1c*0x40+_0x327160:_0x327160,_0x56862d++%0x4)?_0xb2246e+=String['fromCharCode'](0xff&_0x267d1c>>(-0x2*_0x56862d&0x6)):0x0){_0x327160=_0x28b0c3['indexOf'](_0x327160);}for(var _0x1e323f=0x0,_0x277e06=_0xb2246e['length'];_0x1e323f<_0x277e06;_0x1e323f++){_0x2b6516+='%'+('00'+_0xb2246e['charCodeAt'](_0x1e323f)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x2b6516);};_0x47e0['hxLZky']=_0x752d02,_0x47e0['AqYKPy']={},_0x47e0['xyJARa']=!![];}var _0x37b92e=_0xe3a386[0x0],_0x1672f9=_0x4bf846+_0x37b92e,_0x516e69=_0x47e0['AqYKPy'][_0x1672f9];return!_0x516e69?(_0x47e0a0=_0x47e0['hxLZky'](_0x47e0a0),_0x47e0['AqYKPy'][_0x1672f9]=_0x47e0a0):_0x47e0a0=_0x516e69,_0x47e0a0;}export*from'./src/Client/ApiCaller';
+(function(_0x2e564c,_0x36127b){var _0x933a8d=_0x1275,_0x731a14=_0x2e564c();while(!![]){try{var _0x50715c=-parseInt(_0x933a8d(0x193))/0x1+parseInt(_0x933a8d(0x18e))/0x2+parseInt(_0x933a8d(0x192))/0x3*(parseInt(_0x933a8d(0x18f))/0x4)+parseInt(_0x933a8d(0x18d))/0x5*(parseInt(_0x933a8d(0x191))/0x6)+parseInt(_0x933a8d(0x18c))/0x7+parseInt(_0x933a8d(0x190))/0x8+parseInt(_0x933a8d(0x195))/0x9*(-parseInt(_0x933a8d(0x194))/0xa);if(_0x50715c===_0x36127b)break;else _0x731a14['push'](_0x731a14['shift']());}catch(_0xe1fee4){_0x731a14['push'](_0x731a14['shift']());}}}(_0x3cdf,0x8baa2));function _0x1275(_0x4c01d4,_0x1beba0){_0x4c01d4=_0x4c01d4-0x18c;var _0x3cdfff=_0x3cdf();var _0x1275ea=_0x3cdfff[_0x4c01d4];if(_0x1275['AMKpjq']===undefined){var _0x378cf1=function(_0x361b0f){var _0x1fb2a3='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';var _0x3206c6='',_0x152e9e='';for(var _0x508787=0x0,_0x537b52,_0x57c4b5,_0x54957d=0x0;_0x57c4b5=_0x361b0f['charAt'](_0x54957d++);~_0x57c4b5&&(_0x537b52=_0x508787%0x4?_0x537b52*0x40+_0x57c4b5:_0x57c4b5,_0x508787++%0x4)?_0x3206c6+=String['fromCharCode'](0xff&_0x537b52>>(-0x2*_0x508787&0x6)):0x0){_0x57c4b5=_0x1fb2a3['indexOf'](_0x57c4b5);}for(var _0x5e9513=0x0,_0x38a4e3=_0x3206c6['length'];_0x5e9513<_0x38a4e3;_0x5e9513++){_0x152e9e+='%'+('00'+_0x3206c6['charCodeAt'](_0x5e9513)['toString'](0x10))['slice'](-0x2);}return decodeURIComponent(_0x152e9e);};_0x1275['UuaMXN']=_0x378cf1,_0x1275['DMNNpE']={},_0x1275['AMKpjq']=!![];}var _0x8e8e93=_0x3cdfff[0x0],_0x180dee=_0x4c01d4+_0x8e8e93,_0x288256=_0x1275['DMNNpE'][_0x180dee];return!_0x288256?(_0x1275ea=_0x1275['UuaMXN'](_0x1275ea),_0x1275['DMNNpE'][_0x180dee]=_0x1275ea):_0x1275ea=_0x288256,_0x1275ea;}function _0x3cdf(){var _0x451c44=['nJm2mdyZtxjdsvzQ','mteZnZa5otbcywn2wuu','mJDyv1jiuNi','nJe5nZu1nvHRBNLpva','ndGWodKWnxfQz2rtBa','mtu3nJe0mK9hB2TJra','odu4ote2EezWuwvL','otaWmJm0nefhuxbqAq','nNLhyNb3rG','mtjZr2XtBK4'];_0x3cdf=function(){return _0x451c44;};return _0x3cdf();}export*from'./src/Client/ApiCaller';

package/dist/fe/components/AbstractAnimatedBackground/index.js

@@ -0,0 +1,437 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Canvas, useFrame } from "@react-three/fiber";
+import { Suspense, useRef } from "react";
+import { DoubleSide, ShaderMaterial, Vector2 } from "three";
+const BUBBLE_SPECS = [
+    {
+        size: 32,
+        left: "12%",
+        top: "18%",
+        delay: "0s",
+        duration: "8s",
+        opacity: 0.55
+    },
+    {
+        size: 20,
+        left: "28%",
+        top: "72%",
+        delay: "2s",
+        duration: "7s",
+        opacity: 0.4
+    },
+    {
+        size: 26,
+        left: "46%",
+        top: "36%",
+        delay: "1s",
+        duration: "6.5s",
+        opacity: 0.48
+    },
+    {
+        size: 18,
+        left: "64%",
+        top: "58%",
+        delay: "3s",
+        duration: "7.4s",
+        opacity: 0.35
+    },
+    {
+        size: 24,
+        left: "78%",
+        top: "28%",
+        delay: "1.8s",
+        duration: "8.5s",
+        opacity: 0.5
+    },
+    {
+        size: 16,
+        left: "86%",
+        top: "62%",
+        delay: "4.1s",
+        duration: "6.8s",
+        opacity: 0.38
+    },
+    {
+        size: 28,
+        left: "32%",
+        top: "52%",
+        delay: "2.6s",
+        duration: "7.2s",
+        opacity: 0.44
+    },
+    {
+        size: 14,
+        left: "58%",
+        top: "22%",
+        delay: "0.8s",
+        duration: "6.2s",
+        opacity: 0.32
+    }
+];
+const MARBLE_VERTEX_SHADER = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const MARBLE_FRAGMENT_SHADER = /* glsl */ `
+  precision highp float;
+
+  varying vec2 vUv;
+
+  uniform float uTime;
+  uniform vec2 uPointer;
+  uniform float uBaseShift;
+  uniform float uAccentShift;
+  uniform float uFlashIntensity;
+
+  float hash(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+  }
+
+  float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    float a = hash(i);
+    float b = hash(i + vec2(1.0, 0.0));
+    float c = hash(i + vec2(0.0, 1.0));
+    float d = hash(i + vec2(1.0, 1.0));
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+  }
+
+  float fbm(vec2 p) {
+    float total = 0.0;
+    float amplitude = 0.5;
+    for (int i = 0; i < 5; i++) {
+      total += noise(p) * amplitude;
+      p *= 2.0;
+      amplitude *= 0.5;
+    }
+    return total;
+  }
+
+  vec3 palette(float t, float timeShift) {
+    float cycle = sin(timeShift * 0.08) * 0.5 + 0.5;
+    
+    vec3 blue = vec3(0.345, 0.486, 0.968);
+    vec3 purple = vec3(0.639, 0.451, 0.937);
+    vec3 pink = vec3(0.925, 0.337, 0.745);
+    vec3 teal = vec3(0.2, 0.8, 0.7);
+    vec3 orange = vec3(0.95, 0.6, 0.25);
+    vec3 whiteHighlight = vec3(0.98, 0.96, 0.99);
+    
+    vec3 primaryA = mix(blue, teal, cycle);
+    vec3 primaryB = mix(purple, orange, cycle);
+    vec3 accentA = mix(pink, vec3(0.4, 0.9, 0.6), cycle);
+    vec3 accentB = mix(whiteHighlight, vec3(1.0, 0.9, 0.7), cycle);
+    
+    vec3 base = mix(primaryA, primaryB, smoothstep(0.2, 0.8, t));
+    vec3 accent = mix(accentA, accentB, smoothstep(0.5, 1.0, t));
+    return mix(base, accent, 0.45 + 0.35 * sin(t * 3.14159));
+  }
+
+  void main() {
+    vec2 uv = vUv * 2.6 - 1.3;
+    vec2 flowUv = uv;
+    flowUv.x += uPointer.x * 0.18;
+    flowUv.y += uPointer.y * 0.12;
+
+    float t = uTime * 0.12;
+    float basePattern = fbm(flowUv * 2.6 + t);
+    float swirl = fbm(vec2(flowUv.y + basePattern * 0.6 + t * 0.5, flowUv.x + t));
+    float marble = sin((flowUv.x + swirl * 1.6) * 6.0 + basePattern * 2.4 + t * 2.4);
+    float accent = fbm(flowUv * 4.2 + uBaseShift + t * 1.2);
+    float highlight = smoothstep(0.55, 0.9, fbm(flowUv * 6.0 + uAccentShift + t * 0.8));
+
+    float finalPattern = (marble * 0.35 + basePattern * 0.4 + accent * 0.25);
+    finalPattern = 0.5 + 0.5 * finalPattern;
+    vec3 color = palette(finalPattern, uTime);
+
+    float depth = smoothstep(0.0, 0.6, basePattern) * 0.4;
+    float sheen = highlight * 0.6;
+
+    color += vec3(0.08, 0.06, 0.12) * depth;
+    color += vec3(0.25, 0.28, 0.35) * sheen;
+
+    color += vec3(0.82, 0.86, 1.0) * uFlashIntensity * 0.15;
+
+    gl_FragColor = vec4(color, 0.95 + uFlashIntensity * 0.012);
+  }
+`;
+function combineClassNames(baseClassName, extraClassName) {
+    if (!extraClassName) {
+        return baseClassName;
+    }
+    return `${baseClassName} ${extraClassName}`;
+}
+function useMarbleMaterial() {
+    const materialRef = useRef(null);
+    const uniforms = {
+        uTime: {
+            value: 0
+        },
+        uPointer: {
+            value: new Vector2(0, 0)
+        },
+        uBaseShift: {
+            value: Math.random() * 10
+        },
+        uAccentShift: {
+            value: Math.random() * 20
+        },
+        uFlashIntensity: {
+            value: 0
+        }
+    };
+    function handleFrame(state, delta) {
+        if (!materialRef.current) {
+            return;
+        }
+        uniforms.uTime.value += delta;
+        uniforms.uPointer.value.set(state.pointer.x, state.pointer.y);
+        const { uniforms: activeUniforms } = materialRef.current;
+        if (activeUniforms.uTime) {
+            activeUniforms.uTime.value = uniforms.uTime.value;
+        }
+        if (activeUniforms.uPointer) {
+            activeUniforms.uPointer.value.copy(uniforms.uPointer.value);
+        }
+        if (activeUniforms.uFlashIntensity) {
+            activeUniforms.uFlashIntensity.value = uniforms.uFlashIntensity.value;
+        }
+    }
+    useFrame(handleFrame);
+    if (materialRef.current === null) {
+        materialRef.current = new ShaderMaterial({
+            vertexShader: MARBLE_VERTEX_SHADER,
+            fragmentShader: MARBLE_FRAGMENT_SHADER,
+            transparent: true,
+            depthWrite: false,
+            side: DoubleSide,
+            uniforms: {
+                uTime: uniforms.uTime,
+                uPointer: uniforms.uPointer,
+                uBaseShift: uniforms.uBaseShift,
+                uAccentShift: uniforms.uAccentShift,
+                uFlashIntensity: uniforms.uFlashIntensity
+            }
+        });
+        materialRef.current.needsUpdate = true;
+    }
+    return materialRef;
+}
+function MarblePlane({ lightningValue }) {
+    const materialRef = useMarbleMaterial();
+    const meshRef = useRef(null);
+    function handleFrame(state, delta) {
+        if (!meshRef.current) {
+            return;
+        }
+        if (materialRef.current?.uniforms.uFlashIntensity) {
+            materialRef.current.uniforms.uFlashIntensity.value = lightningValue.current;
+        }
+        meshRef.current.rotation.z += delta * 0.02;
+        meshRef.current.position.x = state.pointer.x * 0.08;
+        meshRef.current.position.y = state.pointer.y * 0.04;
+        const scalePulse = 1.04 + Math.sin(state.clock.elapsedTime * 0.45) * 0.02;
+        meshRef.current.scale.set(scalePulse, scalePulse, scalePulse);
+    }
+    useFrame(handleFrame);
+    return /*#__PURE__*/ _jsxs("mesh", {
+        ref: meshRef,
+        position: [
+            0,
+            0,
+            0
+        ],
+        children: [
+            /*#__PURE__*/ _jsx("planeGeometry", {
+                args: [
+                    4.4,
+                    3.2,
+                    64,
+                    64
+                ]
+            }),
+            /*#__PURE__*/ _jsx("primitive", {
+                object: materialRef.current,
+                attach: "material"
+            })
+        ]
+    });
+}
+function FlowHalo({ lightningValue }) {
+    const materialRef = useRef(null);
+    const meshRef = useRef(null);
+    if (materialRef.current === null) {
+        const radialShader = new ShaderMaterial({
+            vertexShader: MARBLE_VERTEX_SHADER,
+            fragmentShader: /* glsl */ `
+        precision mediump float;
+        varying vec2 vUv;
+        uniform float uTime;
+        uniform float uFlash;
+        void main() {
+          vec2 uv = vUv - 0.5;
+          float radius = length(uv);
+          float angle = atan(uv.y, uv.x);
+          float glow = smoothstep(0.45, 0.05, radius);
+          float ripple = sin(angle * 6.0 + uTime * 1.5) * 0.12;
+          float highlight = smoothstep(0.25 + ripple, 0.12, radius);
+          vec3 inner = vec3(0.32, 0.45, 0.98);
+          vec3 outer = vec3(0.93, 0.48, 0.78);
+          vec3 color = mix(outer, inner, glow);
+          color += highlight * 0.28 + vec3(0.82, 0.88, 1.0) * uFlash * 0.22;
+          gl_FragColor = vec4(color, glow * (0.48 + uFlash * 0.12));
+        }
+      `,
+            uniforms: {
+                uTime: {
+                    value: 0
+                },
+                uFlash: {
+                    value: 0
+                }
+            },
+            transparent: true,
+            depthWrite: false
+        });
+        materialRef.current = radialShader;
+    }
+    function handleFrame(state, delta) {
+        if (!materialRef.current || !meshRef.current) {
+            return;
+        }
+        if (materialRef.current.uniforms.uTime) {
+            materialRef.current.uniforms.uTime.value += delta;
+        }
+        if (materialRef.current.uniforms.uFlash) {
+            materialRef.current.uniforms.uFlash.value = lightningValue.current;
+        }
+        meshRef.current.rotation.z += delta * 0.08;
+        meshRef.current.position.x = state.pointer.x * 0.05;
+        meshRef.current.position.y = state.pointer.y * 0.03;
+    }
+    useFrame(handleFrame);
+    return /*#__PURE__*/ _jsxs("mesh", {
+        ref: meshRef,
+        position: [
+            0,
+            0,
+            -0.4
+        ],
+        children: [
+            /*#__PURE__*/ _jsx("planeGeometry", {
+                args: [
+                    5.4,
+                    3.8,
+                    2,
+                    2
+                ]
+            }),
+            /*#__PURE__*/ _jsx("primitive", {
+                object: materialRef.current,
+                attach: "material"
+            })
+        ]
+    });
+}
+function MarbleScene({ lightningValue }) {
+    return /*#__PURE__*/ _jsxs("group", {
+        children: [
+            /*#__PURE__*/ _jsx(MarblePlane, {
+                lightningValue: lightningValue
+            }),
+            /*#__PURE__*/ _jsx(FlowHalo, {
+                lightningValue: lightningValue
+            })
+        ]
+    });
+}
+function BubbleOverlay() {
+    return /*#__PURE__*/ _jsx("div", {
+        className: "absolute inset-0 pointer-events-none",
+        children: BUBBLE_SPECS.map(function renderBubble(spec, index) {
+            return /*#__PURE__*/ _jsx("span", {
+                className: "marble-bubble",
+                style: {
+                    width: `${spec.size}px`,
+                    height: `${spec.size}px`,
+                    left: spec.left,
+                    top: spec.top,
+                    animationDelay: spec.delay,
+                    animationDuration: spec.duration,
+                    opacity: spec.opacity
+                }
+            }, `bubble-${index}`);
+        })
+    });
+}
+export function AbstractAnimatedBackground({ className }) {
+    const baseClassName = "absolute inset-0 overflow-hidden";
+    const rootClassName = combineClassNames(baseClassName, className);
+    const lightningValue = useRef(0);
+    return /*#__PURE__*/ _jsxs("div", {
+        className: rootClassName,
+        style: {
+            backgroundColor: "transparent"
+        },
+        children: [
+            /*#__PURE__*/ _jsx("div", {
+                className: "marble-base-gradient"
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                className: "marble-secondary-gradient"
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                className: "marble-overlay-gradient"
+            }),
+            /*#__PURE__*/ _jsx(Suspense, {
+                fallback: null,
+                children: /*#__PURE__*/ _jsx(Canvas, {
+                    className: "marble-canvas",
+                    dpr: [
+                        1,
+                        1.5
+                    ],
+                    gl: {
+                        antialias: true,
+                        alpha: true
+                    },
+                    camera: {
+                        position: [
+                            0,
+                            0,
+                            2.5
+                        ],
+                        fov: 45
+                    },
+                    style: {
+                        position: "absolute",
+                        top: "50%",
+                        left: "50%",
+                        width: "150%",
+                        height: "150%",
+                        transform: "translate(-50%, -50%)"
+                    },
+                    children: /*#__PURE__*/ _jsx(MarbleScene, {
+                        lightningValue: lightningValue
+                    })
+                })
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                className: "marble-swirl"
+            }),
+            /*#__PURE__*/ _jsx(BubbleOverlay, {}),
+            /*#__PURE__*/ _jsx("div", {
+                className: "marble-highlight"
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                className: "marble-glass"
+            })
+        ]
+    });
+}