dune-react 0.0.1

package/dist/components/ui-custom/sparkles.js

@@ -0,0 +1,418 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../utils/css-utils.js";
+import { initParticlesEngine as n } from "../../node_modules/.pnpm/@tsparticles_react@3.0.0_@tsparticles_engine@3.9.1_react-dom@18.3.1_react@18.3.1/node_modules/@tsparticles/react/dist/index.js";
+import { loadSlim } from "../../node_modules/.pnpm/@tsparticles_slim@3.9.1/node_modules/@tsparticles/slim/browser/index.js";
+import { useState, useEffect, useId } from "react";
+import f from "../../node_modules/.pnpm/@tsparticles_react@3.0.0_@tsparticles_engine@3.9.1_react-dom@18.3.1_react@18.3.1/node_modules/@tsparticles/react/dist/Particles.js";
+import { useAnimation, motion } from "framer-motion";
+const SparklesCore = (props) => {
+  const {
+    id,
+    className,
+    background,
+    minSize,
+    maxSize,
+    speed,
+    particleColor,
+    particleDensity
+  } = props;
+  const [init, setInit] = useState(false);
+  useEffect(() => {
+    n(async (engine) => {
+      await loadSlim(engine);
+    }).then(() => {
+      setInit(true);
+    });
+  }, []);
+  const controls = useAnimation();
+  const particlesLoaded = async (container) => {
+    if (container) {
+      controls.start({
+        opacity: 1,
+        transition: {
+          duration: 1
+        }
+      });
+    }
+  };
+  const generatedId = useId();
+  return /* @__PURE__ */ jsx(motion.div, { animate: controls, className: cn("opacity-0", className), children: init && /* @__PURE__ */ jsx(
+    f,
+    {
+      id: id || generatedId,
+      className: cn("h-full w-full"),
+      particlesLoaded,
+      options: {
+        background: {
+          color: {
+            value: background || "#0d47a1"
+          }
+        },
+        fullScreen: {
+          enable: false,
+          zIndex: 1
+        },
+        fpsLimit: 120,
+        interactivity: {
+          events: {
+            onClick: {
+              enable: true,
+              mode: "push"
+            },
+            onHover: {
+              enable: false,
+              mode: "repulse"
+            },
+            resize: true
+          },
+          modes: {
+            push: {
+              quantity: 4
+            },
+            repulse: {
+              distance: 200,
+              duration: 0.4
+            }
+          }
+        },
+        particles: {
+          bounce: {
+            horizontal: {
+              value: 1
+            },
+            vertical: {
+              value: 1
+            }
+          },
+          collisions: {
+            absorb: {
+              speed: 2
+            },
+            bounce: {
+              horizontal: {
+                value: 1
+              },
+              vertical: {
+                value: 1
+              }
+            },
+            enable: false,
+            maxSpeed: 50,
+            mode: "bounce",
+            overlap: {
+              enable: true,
+              retries: 0
+            }
+          },
+          color: {
+            value: particleColor || "#ffffff",
+            animation: {
+              h: {
+                count: 0,
+                enable: false,
+                speed: 1,
+                decay: 0,
+                delay: 0,
+                sync: true,
+                offset: 0
+              },
+              s: {
+                count: 0,
+                enable: false,
+                speed: 1,
+                decay: 0,
+                delay: 0,
+                sync: true,
+                offset: 0
+              },
+              l: {
+                count: 0,
+                enable: false,
+                speed: 1,
+                decay: 0,
+                delay: 0,
+                sync: true,
+                offset: 0
+              }
+            }
+          },
+          effect: {
+            close: true,
+            fill: true,
+            options: {},
+            type: {}
+          },
+          groups: {},
+          move: {
+            angle: {
+              offset: 0,
+              value: 90
+            },
+            attract: {
+              distance: 200,
+              enable: false,
+              rotate: {
+                x: 3e3,
+                y: 3e3
+              }
+            },
+            center: {
+              x: 50,
+              y: 50,
+              mode: "percent",
+              radius: 0
+            },
+            decay: 0,
+            distance: {},
+            direction: "none",
+            drift: 0,
+            enable: true,
+            gravity: {
+              acceleration: 9.81,
+              enable: false,
+              inverse: false,
+              maxSpeed: 50
+            },
+            path: {
+              clamp: true,
+              delay: {
+                value: 0
+              },
+              enable: false,
+              options: {}
+            },
+            outModes: {
+              default: "out"
+            },
+            random: false,
+            size: false,
+            speed: {
+              min: 0.1,
+              max: 1
+            },
+            spin: {
+              acceleration: 0,
+              enable: false
+            },
+            straight: false,
+            trail: {
+              enable: false,
+              length: 10,
+              fill: {}
+            },
+            vibrate: false,
+            warp: false
+          },
+          number: {
+            density: {
+              enable: true,
+              width: 400,
+              height: 400
+            },
+            limit: {
+              mode: "delete",
+              value: 0
+            },
+            value: particleDensity || 120
+          },
+          opacity: {
+            value: {
+              min: 0.1,
+              max: 1
+            },
+            animation: {
+              count: 0,
+              enable: true,
+              speed: speed || 4,
+              decay: 0,
+              delay: 0,
+              sync: false,
+              mode: "auto",
+              startValue: "random",
+              destroy: "none"
+            }
+          },
+          reduceDuplicates: false,
+          shadow: {
+            blur: 0,
+            color: {
+              value: "#000"
+            },
+            enable: false,
+            offset: {
+              x: 0,
+              y: 0
+            }
+          },
+          shape: {
+            close: true,
+            fill: true,
+            options: {},
+            type: "circle"
+          },
+          size: {
+            value: {
+              min: minSize || 1,
+              max: maxSize || 3
+            },
+            animation: {
+              count: 0,
+              enable: false,
+              speed: 5,
+              decay: 0,
+              delay: 0,
+              sync: false,
+              mode: "auto",
+              startValue: "random",
+              destroy: "none"
+            }
+          },
+          stroke: {
+            width: 0
+          },
+          zIndex: {
+            value: 0,
+            opacityRate: 1,
+            sizeRate: 1,
+            velocityRate: 1
+          },
+          destroy: {
+            bounds: {},
+            mode: "none",
+            split: {
+              count: 1,
+              factor: {
+                value: 3
+              },
+              rate: {
+                value: {
+                  min: 4,
+                  max: 9
+                }
+              },
+              sizeOffset: true
+            }
+          },
+          roll: {
+            darken: {
+              enable: false,
+              value: 0
+            },
+            enable: false,
+            enlighten: {
+              enable: false,
+              value: 0
+            },
+            mode: "vertical",
+            speed: 25
+          },
+          tilt: {
+            value: 0,
+            animation: {
+              enable: false,
+              speed: 0,
+              decay: 0,
+              sync: false
+            },
+            direction: "clockwise",
+            enable: false
+          },
+          twinkle: {
+            lines: {
+              enable: false,
+              frequency: 0.05,
+              opacity: 1
+            },
+            particles: {
+              enable: false,
+              frequency: 0.05,
+              opacity: 1
+            }
+          },
+          wobble: {
+            distance: 5,
+            enable: false,
+            speed: {
+              angle: 50,
+              move: 10
+            }
+          },
+          life: {
+            count: 0,
+            delay: {
+              value: 0,
+              sync: false
+            },
+            duration: {
+              value: 0,
+              sync: false
+            }
+          },
+          rotate: {
+            value: 0,
+            animation: {
+              enable: false,
+              speed: 0,
+              decay: 0,
+              sync: false
+            },
+            direction: "clockwise",
+            path: false
+          },
+          orbit: {
+            animation: {
+              count: 0,
+              enable: false,
+              speed: 1,
+              decay: 0,
+              delay: 0,
+              sync: false
+            },
+            enable: false,
+            opacity: 1,
+            rotation: {
+              value: 45
+            },
+            width: 1
+          },
+          links: {
+            blink: false,
+            color: {
+              value: "#fff"
+            },
+            consent: false,
+            distance: 100,
+            enable: false,
+            frequency: 1,
+            opacity: 1,
+            shadow: {
+              blur: 5,
+              color: {
+                value: "#000"
+              },
+              enable: false
+            },
+            triangles: {
+              enable: false,
+              frequency: 1
+            },
+            width: 1,
+            warp: false
+          },
+          repulse: {
+            value: 0,
+            enabled: false,
+            distance: 1,
+            duration: 1,
+            factor: 1,
+            speed: 1
+          }
+        },
+        detectRetina: true
+      }
+    }
+  ) });
+};
+export {
+  SparklesCore
+};

package/dist/components/ui-custom/spotlight-new.d.ts

@@ -0,0 +1,13 @@
+type SpotlightProps = {
+    gradientFirst?: string;
+    gradientSecond?: string;
+    gradientThird?: string;
+    translateY?: number;
+    width?: number;
+    height?: number;
+    smallWidth?: number;
+    duration?: number;
+    xOffset?: number;
+};
+export declare const Spotlight: ({ gradientFirst, gradientSecond, gradientThird, translateY, width, height, smallWidth, duration, xOffset, }?: SpotlightProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils/index.ts";
+export * from "./components/index.ts";

package/dist/index.js

@@ -0,0 +1,40 @@
+import { filterEmptyValues } from "./utils/utils-common.js";
+import { formatLargeNumber, getUrlWithParams } from "./utils/utils-api.js";
+import { formatTimeAgo, formatTimeString, getTimeDetails, getTimestamp, sleep, timeAgo } from "./utils/utils-time.js";
+import { base64ToFile, base64ToUrl, blobToBase64, blobToUrl, convertBase64ToBlob, structureFile } from "./utils/utils-canvas.js";
+import { cn, liquidGlass } from "./utils/css-utils.js";
+import "./utils/storage-qetag.js";
+import { downloadImage, downloadImageClient, fetchHasOnlineFile, getBase64Client, isValidFileSize, isValidFileType } from "./utils/utils-image.js";
+import { nanoid } from "./utils/utils-random.js";
+import { default as default2 } from "./components/ui-custom/background.js";
+import { Cover } from "./components/ui-custom/cover.js";
+import { SparklesCore } from "./components/ui-custom/sparkles.js";
+export {
+  default2 as Background,
+  Cover,
+  SparklesCore,
+  base64ToFile,
+  base64ToUrl,
+  blobToBase64,
+  blobToUrl,
+  cn,
+  convertBase64ToBlob,
+  downloadImage,
+  downloadImageClient,
+  fetchHasOnlineFile,
+  filterEmptyValues,
+  formatLargeNumber,
+  formatTimeAgo,
+  formatTimeString,
+  getBase64Client,
+  getTimeDetails,
+  getTimestamp,
+  getUrlWithParams,
+  isValidFileSize,
+  isValidFileType,
+  liquidGlass,
+  nanoid,
+  sleep,
+  structureFile,
+  timeAgo
+};

package/dist/node_modules/.pnpm/@fluid-tailwind_tailwind-merge@0.0.3_tailwind-merge@3.3.1/node_modules/@fluid-tailwind/tailwind-merge/dist/index.js

@@ -0,0 +1,50 @@
+import { mergeConfigs } from "../../../../../tailwind-merge@3.3.1/node_modules/tailwind-merge/dist/bundle-mjs.js";
+function withFluid(config) {
+  if (config.prefix)
+    throw new Error(`@fluid-tailwind/tailwind-merge doesn't work with custom prefixes`);
+  const isThemeGetter = (def) => typeof def === "function" && "isThemeGetter" in def && def.isThemeGetter;
+  const buildFluidValidator = (defs) => (val) => {
+    const parts = val.split("/");
+    return parts.length === 2 && defs.length > 0 && parts.every((v) => defs.some((d) => typeof d === "string" ? d === v : d(v)));
+  };
+  const resolveThemeGetters = (group) => group.flatMap((def) => isThemeGetter(def) ? resolveThemeGetters(def(config.theme)) : [def]);
+  const fluidizeClassGroup = (group, toplevel = false) => {
+    const objDefs = [];
+    const nonObjDefs = [];
+    resolveThemeGetters(group).forEach((def) => {
+      if (typeof def !== "object") return !toplevel && nonObjDefs.push(def);
+      objDefs.push(
+        Object.fromEntries(
+          Object.entries(def).flatMap(([name, defs]) => {
+            const newDefs = fluidizeClassGroup(defs);
+            return toplevel ? [
+              [`~${name}`, newDefs],
+              [`~-${name}`, newDefs]
+            ] : [[name, newDefs]];
+          })
+        )
+      );
+    });
+    return [buildFluidValidator(nonObjDefs), ...objDefs];
+  };
+  const classGroups = Object.fromEntries(
+    Object.entries(config.classGroups).map(([name, group]) => {
+      return [name, fluidizeClassGroup(group, true).slice(1)];
+    })
+  );
+  return mergeConfigs(config, {
+    extend: {
+      classGroups
+    },
+    experimentalParseClassName({ className, parseClassName }) {
+      const parsed = parseClassName(className);
+      return {
+        ...parsed,
+        modifiers: parsed.modifiers.filter((modifier) => !modifier.startsWith("~"))
+      };
+    }
+  });
+}
+export {
+  withFluid
+};

package/dist/node_modules/.pnpm/@tsparticles_basic@3.9.1/node_modules/@tsparticles/basic/browser/index.js

@@ -0,0 +1,25 @@
+import { loadBaseMover } from "../../../../../@tsparticles_move-base@3.9.1/node_modules/@tsparticles/move-base/browser/index.js";
+import { loadCircleShape } from "../../../../../@tsparticles_shape-circle@3.9.1/node_modules/@tsparticles/shape-circle/browser/index.js";
+import { loadColorUpdater } from "../../../../../@tsparticles_updater-color@3.9.1/node_modules/@tsparticles/updater-color/browser/index.js";
+import { loadHexColorPlugin } from "../../../../../@tsparticles_plugin-hex-color@3.9.1/node_modules/@tsparticles/plugin-hex-color/browser/index.js";
+import { loadHslColorPlugin } from "../../../../../@tsparticles_plugin-hsl-color@3.9.1/node_modules/@tsparticles/plugin-hsl-color/browser/index.js";
+import { loadOpacityUpdater } from "../../../../../@tsparticles_updater-opacity@3.9.1/node_modules/@tsparticles/updater-opacity/browser/index.js";
+import { loadOutModesUpdater } from "../../../../../@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/index.js";
+import { loadRgbColorPlugin } from "../../../../../@tsparticles_plugin-rgb-color@3.9.1/node_modules/@tsparticles/plugin-rgb-color/browser/index.js";
+import { loadSizeUpdater } from "../../../../../@tsparticles_updater-size@3.9.1/node_modules/@tsparticles/updater-size/browser/index.js";
+async function loadBasic(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await loadHexColorPlugin(engine, false);
+  await loadHslColorPlugin(engine, false);
+  await loadRgbColorPlugin(engine, false);
+  await loadBaseMover(engine, false);
+  await loadCircleShape(engine, false);
+  await loadColorUpdater(engine, false);
+  await loadOpacityUpdater(engine, false);
+  await loadOutModesUpdater(engine, false);
+  await loadSizeUpdater(engine, false);
+  await engine.refresh(refresh);
+}
+export {
+  loadBasic
+};