not-a-spinner 0.1.0

package/dist/index.cjs

@@ -0,0 +1,551 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  NotASpinner: () => NotASpinner,
+  cn: () => cn,
+  createAnthropicFetcher: () => createAnthropicFetcher,
+  createOpenAIFetcher: () => createOpenAIFetcher,
+  getPhrasesForConfig: () => getPhrasesForConfig,
+  notASpinnerVariants: () => notASpinnerVariants,
+  phrases: () => phrases,
+  shufflePhrases: () => shufflePhrases,
+  useTextRotation: () => useTextRotation
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+
+// src/not-a-spinner.tsx
+var React = __toESM(require("react"), 1);
+var import_class_variance_authority = require("class-variance-authority");
+
+// src/use-text-rotation.ts
+var import_react = require("react");
+
+// src/phrases.ts
+var phrases = {
+  en: [
+    "Contemplating the meaning of null",
+    "Asking the rubber duck",
+    "Reticulating splines",
+    "Consulting the ancient scrolls",
+    "Negotiating with the API gods",
+    "Untangling spaghetti code",
+    "Feeding the hamsters that power the server",
+    "Converting caffeine to code",
+    "Aligning the cosmic bits",
+    "Performing mass speculation",
+    "Warming up the neural pathways",
+    "Bribing the cache fairy",
+    "Dividing by almost zero",
+    "Searching for the missing semicolon",
+    "Teaching electrons to think",
+    "Compiling excuses",
+    "Reversing entropy locally",
+    "Summoning the async wizard",
+    "Polishing the pixels",
+    "Calculating the meaning of life",
+    "Downloading more RAM",
+    "Defragmenting the thought process",
+    "Poking the language model",
+    "Waiting for the stars to align",
+    "Generating plausible nonsense",
+    "Consulting the magic 8-ball API",
+    "Herding digital cats",
+    "Overthinking at machine speed",
+    "Pretending to be busy",
+    "Running on vibes and vectors"
+  ],
+  zh: [
+    "\u8BA9AI\u518D\u60F3\u60F3",
+    "\u6B63\u5728\u6478\u9C7C\u5F0F\u601D\u8003",
+    "\u6B63\u5728\u7FFB\u9605\u7956\u4F20\u4EE3\u7801",
+    "\u6B63\u5728\u548Cbug\u8C08\u5224",
+    "\u75AF\u72C2\u6697\u793A\u670D\u52A1\u5668\u52A0\u901F",
+    "\u6B63\u5728\u8585\u7F8A\u6BDB\u5F0F\u8BA1\u7B97",
+    "\u5047\u88C5\u5F88\u5FD9\u7684\u6837\u5B50",
+    "\u6B63\u5728\u91CF\u5B50\u7EA0\u7F20\u4E2D",
+    "\u8BA9\u5B50\u5F39\u98DE\u4E00\u4F1A\u513F",
+    "\u6B63\u5728\u52A0\u8F7D\u4EBA\u751F\u7684\u610F\u4E49",
+    "\u6B63\u5728\u6478\u7D22\u5B87\u5B99\u7684\u89C4\u5F8B",
+    "\u8DDF\u7F13\u5B58\u7CBE\u7075\u8BA8\u4EF7\u8FD8\u4EF7",
+    "\u6B63\u5728\u70BC\u4E39",
+    "\u8BF7\u6C42\u795E\u7ECF\u7F51\u7EDC\u5F00\u4E2A\u540E\u95E8",
+    "\u6B63\u5728\u6D88\u5316\u4F60\u7684\u8BF7\u6C42",
+    "\u6316\u77FF\u4E2D\u8BF7\u7A0D\u5019",
+    "\u6B63\u5728\u7FFB\u8BD1\u673A\u5668\u8BED\u8A00",
+    "\u5927\u8111\u6B63\u5728\u8D85\u9891\u8FD0\u884C",
+    "\u6B63\u5728\u627E\u7075\u611F",
+    "\u5411\u670D\u52A1\u5668\u53D1\u9001\u8D3F\u8D42",
+    "\u6B63\u5728\u8FDB\u884C\u610F\u5FF5\u52A0\u901F",
+    "\u8BA9\u4EE3\u7801\u5148\u8DD1\u4E00\u4F1A\u513F",
+    "\u6B63\u5728\u65BD\u5C55\u6570\u636E\u9B54\u6CD5",
+    "\u5077\u5077\u67E5\u770B\u7B54\u6848\u4E2D",
+    "\u6B63\u5728\u89E3\u5F00\u859B\u5B9A\u8C14\u7684Bug",
+    "\u62FC\u547D\u601D\u8003\u4E0D\u8981\u50AC",
+    "\u6B63\u5728\u548CAI\u540C\u4E8B\u5F00\u4F1A",
+    "\u7A7F\u8D8A\u6570\u636E\u7684\u661F\u8FB0\u5927\u6D77",
+    "\u6B63\u5728\u8FDB\u884C\u7075\u9B42\u62F7\u95EE",
+    "\u7B49\u7B49\u9A6C\u4E0A\u5C31\u597D"
+  ],
+  ja: [
+    "AI\u304C\u60A9\u3093\u3067\u3044\u307E\u3059",
+    "\u30B9\u30D1\u30B2\u30C3\u30C6\u30A3\u30B3\u30FC\u30C9\u3092\u89E3\u8AAD\u4E2D",
+    "\u30B4\u30E0\u306E\u30A2\u30D2\u30EB\u306B\u76F8\u8AC7\u4E2D",
+    "\u30B5\u30FC\u30D0\u30FC\u306E\u30CF\u30E0\u30B9\u30BF\u30FC\u3092\u8D77\u52D5\u4E2D",
+    "\u30AB\u30D5\u30A7\u30A4\u30F3\u3092\u30B3\u30FC\u30C9\u306B\u5909\u63DB\u4E2D",
+    "\u5B87\u5B99\u306E\u30D3\u30C3\u30C8\u3092\u6574\u5217\u4E2D",
+    "\u30BB\u30DF\u30B3\u30ED\u30F3\u3092\u63A2\u7D22\u4E2D",
+    "\u96FB\u5B50\u306B\u8003\u3048\u308B\u3053\u3068\u3092\u6559\u80B2\u4E2D",
+    "\u8A00\u3044\u8A33\u3092\u30B3\u30F3\u30D1\u30A4\u30EB\u4E2D",
+    "\u975E\u540C\u671F\u306E\u9B54\u6CD5\u4F7F\u3044\u3092\u53EC\u559A\u4E2D",
+    "\u30D4\u30AF\u30BB\u30EB\u3092\u78E8\u304D\u4E2D",
+    "\u4EBA\u751F\u306E\u610F\u5473\u3092\u8A08\u7B97\u4E2D",
+    "RAM\u3092\u30C0\u30A6\u30F3\u30ED\u30FC\u30C9\u4E2D",
+    "\u601D\u8003\u30D7\u30ED\u30BB\u30B9\u3092\u30C7\u30D5\u30E9\u30B0\u4E2D",
+    "\u30DE\u30B7\u30F3\u901F\u5EA6\u3067\u8003\u3048\u3059\u304E\u4E2D",
+    "\u91CF\u5B50\u306E\u3082\u3064\u308C\u3092\u89E3\u6D88\u4E2D",
+    "API\u306E\u795E\u69D8\u3068\u4EA4\u6E09\u4E2D",
+    "\u30C7\u30B8\u30BF\u30EB\u732B\u3092\u8FFD\u3044\u304B\u3051\u4E2D",
+    "\u30CB\u30E5\u30FC\u30E9\u30EB\u30D1\u30B9\u3092\u6696\u3081\u4E2D",
+    "\u30C7\u30FC\u30BF\u306E\u6D77\u3092\u6CF3\u3044\u3067\u3044\u307E\u3059",
+    "\u30D0\u30B0\u3068\u548C\u89E3\u4EA4\u6E09\u4E2D",
+    "\u5FD9\u3057\u3044\u3075\u308A\u3092\u3057\u3066\u3044\u307E\u3059",
+    "\u30A2\u30EB\u30B4\u30EA\u30BA\u30E0\u304C\u7791\u60F3\u4E2D",
+    "\u9B54\u6CD5\u306E8\u30DC\u30FC\u30EB\u306B\u805E\u3044\u3066\u307E\u3059",
+    "\u3082\u3046\u3061\u3087\u3063\u3068\u5F85\u3063\u3066\u306D",
+    "\u5168\u529B\u3067\u51E6\u7406\u3057\u3066\u3044\u307E\u3059",
+    "\u7B54\u3048\u306E\u8FD1\u304F\u306B\u3044\u307E\u3059",
+    "\u5929\u624D\u7684\u306A\u3072\u3089\u3081\u304D\u3092\u5F85\u6A5F\u4E2D",
+    "\u30B3\u30FC\u30D2\u30FC\u30D6\u30EC\u30A4\u30AF\u4E2D\u3067\u3059",
+    "\u9811\u5F35\u3063\u3066\u8003\u3048\u4E2D"
+  ],
+  es: [
+    "Consultando al or\xE1culo digital",
+    "Pensando intensamente",
+    "Negociando con los dioses del API",
+    "Desenredando c\xF3digo espagueti",
+    "Alimentando los h\xE1msters del servidor",
+    "Convirtiendo cafe\xEDna en c\xF3digo",
+    "Alineando los bits c\xF3smicos",
+    "Buscando el punto y coma perdido",
+    "Ense\xF1ando a pensar a los electrones",
+    "Compilando excusas creativas",
+    "Invocando al mago as\xEDncrono",
+    "Puliendo los p\xEDxeles",
+    "Calculando el sentido de la vida",
+    "Descargando m\xE1s RAM",
+    "Preguntando al pato de goma",
+    "Pastoreando gatos digitales",
+    "Sobrepensando a velocidad m\xE1quina",
+    "Fingiendo estar ocupado",
+    "Sobornando al hada del cach\xE9",
+    "Dividiendo por casi cero",
+    "Generando tonter\xEDas plausibles",
+    "Calentando las rutas neuronales",
+    "Esperando que se alineen las estrellas",
+    "Haciendo magia con los datos",
+    "Meditando algor\xEDtmicamente",
+    "Revolviendo la sopa cu\xE1ntica",
+    "Susurrando al servidor",
+    "Recalibrando la realidad",
+    "Casi casi ya casi",
+    "Un momento de genialidad en curso"
+  ],
+  fr: [
+    "Consultation de l'oracle num\xE9rique",
+    "R\xE9flexion intense en cours",
+    "N\xE9gociation avec les dieux de l'API",
+    "D\xE9m\xEAlage de code spaghetti",
+    "Conversion de caf\xE9ine en code",
+    "Alignement des bits cosmiques",
+    "Recherche du point-virgule perdu",
+    "Compilation d'excuses cr\xE9atives",
+    "Invocation du sorcier asynchrone",
+    "Polissage des pixels",
+    "Calcul du sens de la vie",
+    "T\xE9l\xE9chargement de RAM suppl\xE9mentaire",
+    "Consultation du canard en caoutchouc",
+    "Rassemblement de chats num\xE9riques",
+    "Surr\xE9flexion \xE0 vitesse machine",
+    "Simulation d'activit\xE9 intense",
+    "Corruption de la f\xE9e du cache",
+    "R\xE9chauffement des voies neuronales",
+    "G\xE9n\xE9ration de b\xEAtises plausibles",
+    "M\xE9ditation algorithmique",
+    "Persuasion quantique en cours",
+    "Interrogation de la boule magique",
+    "D\xE9fragmentation de la pens\xE9e",
+    "Dressage des \xE9lectrons pensants",
+    "Attente de l'alignement stellaire",
+    "Magie des donn\xE9es en cours",
+    "Murmures au serveur",
+    "Recalibrage de la r\xE9alit\xE9",
+    "Presque presque bient\xF4t",
+    "Un \xE9clair de g\xE9nie arrive"
+  ],
+  de: [
+    "Algorithmus gr\xFCbelt nach",
+    "Daten werden meditiert",
+    "Verhandlung mit den API-G\xF6ttern",
+    "Spaghetti-Code wird entwirrt",
+    "Server-Hamster werden gef\xFCttert",
+    "Koffein wird in Code umgewandelt",
+    "Kosmische Bits werden ausgerichtet",
+    "Das fehlende Semikolon wird gesucht",
+    "Elektronen lernen das Denken",
+    "Ausreden werden kompiliert",
+    "Der asynchrone Zauberer wird beschworen",
+    "Pixel werden poliert",
+    "Der Sinn des Lebens wird berechnet",
+    "Mehr RAM wird heruntergeladen",
+    "Die Gummiente wird befragt",
+    "Digitale Katzen werden geh\xFCtet",
+    "Maschinengeschwindigkeit-\xDCberdenken",
+    "Besch\xE4ftigt-Sein wird simuliert",
+    "Die Cache-Fee wird bestochen",
+    "Beinahe durch Null geteilt",
+    "Plausibeler Unsinn wird generiert",
+    "Neuronale Pfade werden aufgew\xE4rmt",
+    "Quantensuppe wird umger\xFChrt",
+    "Sternenausrichtung wird abgewartet",
+    "Datenmagie wird ausgef\xFChrt",
+    "Dem Server wird zugefl\xFCstert",
+    "Realit\xE4t wird neu kalibriert",
+    "Gleich gleich fast fertig",
+    "Ein Geistesblitz ist unterwegs",
+    "Intensives Nachdenken l\xE4uft"
+  ],
+  ko: [
+    "AI\uAC00 \uACE0\uBBFC \uC911",
+    "\uB370\uC774\uD130\uB97C \uBA85\uC0C1 \uC911",
+    "\uACE0\uBB34 \uC624\uB9AC\uC5D0\uAC8C \uC0C1\uB2F4 \uC911",
+    "\uC11C\uBC84 \uD584\uC2A4\uD130\uC5D0\uAC8C \uBC25 \uC8FC\uB294 \uC911",
+    "\uCE74\uD398\uC778\uC744 \uCF54\uB4DC\uB85C \uBCC0\uD658 \uC911",
+    "\uC6B0\uC8FC \uBE44\uD2B8\uB97C \uC815\uB82C \uC911",
+    "\uC783\uC5B4\uBC84\uB9B0 \uC138\uBBF8\uCF5C\uB860 \uCC3E\uB294 \uC911",
+    "\uC804\uC790\uC5D0\uAC8C \uC0DD\uAC01\uD558\uB294 \uBC95 \uAC00\uB974\uCE58\uB294 \uC911",
+    "\uBCC0\uBA85\uC744 \uCEF4\uD30C\uC77C \uC911",
+    "\uBE44\uB3D9\uAE30 \uB9C8\uBC95\uC0AC \uC18C\uD658 \uC911",
+    "\uD53D\uC140\uC744 \uB2E6\uB294 \uC911",
+    "\uC778\uC0DD\uC758 \uC758\uBBF8 \uACC4\uC0B0 \uC911",
+    "RAM \uB2E4\uC6B4\uB85C\uB4DC \uC911",
+    "\uB514\uC9C0\uD138 \uACE0\uC591\uC774 \uBAB0\uC774 \uC911",
+    "\uBA38\uC2E0 \uC18D\uB3C4\uB85C \uACFC\uB3C4\uD558\uAC8C \uC0DD\uAC01 \uC911",
+    "\uBC14\uC05C \uCC99\uD558\uB294 \uC911",
+    "\uCE90\uC2DC \uC694\uC815\uC5D0\uAC8C \uB1CC\uBB3C \uC8FC\uB294 \uC911",
+    "\uAC70\uC758 0\uC73C\uB85C \uB098\uB204\uB294 \uC911",
+    "\uADF8\uB7F4\uB4EF\uD55C \uD5DB\uC18C\uB9AC \uC0DD\uC131 \uC911",
+    "\uC2E0\uACBD \uACBD\uB85C \uC6CC\uBC0D\uC5C5 \uC911",
+    "\uC591\uC790 \uC218\uD504 \uC813\uB294 \uC911",
+    "\uBCC4\uC774 \uC815\uB82C\uB418\uAE38 \uAE30\uB2E4\uB9AC\uB294 \uC911",
+    "\uB370\uC774\uD130 \uB9C8\uBC95 \uC2DC\uC804 \uC911",
+    "\uC11C\uBC84\uC5D0\uAC8C \uC18D\uC0AD\uC774\uB294 \uC911",
+    "\uD604\uC2E4 \uC7AC\uBCF4\uC815 \uC911",
+    "\uAC70\uC758 \uAC70\uC758 \uB2E4 \uB410\uC5B4\uC694",
+    "\uCC9C\uC7AC\uC801 \uC601\uAC10 \uB300\uAE30 \uC911",
+    "\uC2A4\uD30C\uAC8C\uD2F0 \uCF54\uB4DC \uD574\uB3C5 \uC911",
+    "API \uC2E0\uACFC \uD611\uC0C1 \uC911",
+    "\uC5F4\uC2EC\uD788 \uC0DD\uAC01\uD558\uB294 \uC911"
+  ]
+};
+function shufflePhrases(input) {
+  const arr = [...input];
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+function getPhrasesForConfig(messages, locale) {
+  if (messages && messages.length > 0) return messages;
+  if (locale && phrases[locale]) return phrases[locale];
+  return phrases.en;
+}
+
+// src/use-text-rotation.ts
+function useTextRotation({
+  phrases: inputPhrases,
+  interval = 3e3,
+  animationDuration = 400
+}) {
+  const [currentIndex, setCurrentIndex] = (0, import_react.useState)(0);
+  const [isExiting, setIsExiting] = (0, import_react.useState)(false);
+  const [isEntering, setIsEntering] = (0, import_react.useState)(false);
+  const poolRef = (0, import_react.useRef)(inputPhrases);
+  const initializedRef = (0, import_react.useRef)(false);
+  const timerRef = (0, import_react.useRef)(null);
+  const mountedRef = (0, import_react.useRef)(true);
+  (0, import_react.useEffect)(() => {
+    if (!initializedRef.current) {
+      poolRef.current = shufflePhrases(inputPhrases);
+      initializedRef.current = true;
+      setCurrentIndex(0);
+    }
+  }, []);
+  (0, import_react.useEffect)(() => {
+    poolRef.current = shufflePhrases(inputPhrases);
+    setCurrentIndex(0);
+  }, [inputPhrases]);
+  const appendPhrases = (0, import_react.useCallback)((newPhrases) => {
+    const current = poolRef.current;
+    const combined = [...current, ...newPhrases];
+    if (combined.length > 20) {
+      poolRef.current = combined.slice(combined.length - 20);
+    } else {
+      poolRef.current = combined;
+    }
+  }, []);
+  (0, import_react.useEffect)(() => {
+    mountedRef.current = true;
+    if (poolRef.current.length <= 1) return;
+    timerRef.current = setInterval(() => {
+      if (!mountedRef.current) return;
+      setIsExiting(true);
+      setTimeout(() => {
+        if (!mountedRef.current) return;
+        setIsExiting(false);
+        setCurrentIndex((prev) => {
+          const next = prev + 1;
+          if (next >= poolRef.current.length) {
+            poolRef.current = shufflePhrases(poolRef.current);
+            return 0;
+          }
+          return next;
+        });
+        setIsEntering(true);
+        setTimeout(() => {
+          if (!mountedRef.current) return;
+          setIsEntering(false);
+        }, animationDuration);
+      }, animationDuration);
+    }, interval);
+    return () => {
+      mountedRef.current = false;
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+  }, [interval, animationDuration]);
+  const pool = poolRef.current;
+  const phrase = pool.length > 0 ? pool[currentIndex % pool.length] : "";
+  return {
+    currentPhrase: phrase,
+    isExiting,
+    isEntering,
+    appendPhrases
+  };
+}
+
+// src/not-a-spinner.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var notASpinnerVariants = (0, import_class_variance_authority.cva)("nas-base", {
+  variants: {
+    size: {
+      sm: "nas-sm",
+      default: "nas-default",
+      lg: "nas-lg"
+    },
+    animation: {
+      fade: "nas-animation-fade",
+      typewriter: "nas-animation-typewriter",
+      slide: "nas-animation-slide",
+      blur: "nas-animation-blur"
+    }
+  },
+  defaultVariants: {
+    size: "default",
+    animation: "fade"
+  }
+});
+var NotASpinner = React.forwardRef(
+  ({
+    className,
+    size,
+    animation = "fade",
+    messages,
+    locale,
+    fetchPhrase,
+    interval = 3e3,
+    dots = true,
+    ...props
+  }, ref) => {
+    const resolvedPhrases = React.useMemo(
+      () => getPhrasesForConfig(messages, locale),
+      [messages, locale]
+    );
+    const { currentPhrase, isExiting, isEntering, appendPhrases } = useTextRotation({
+      phrases: resolvedPhrases,
+      interval
+    });
+    React.useEffect(() => {
+      if (!fetchPhrase) return;
+      let cancelled = false;
+      const fetchInterval = setInterval(async () => {
+        if (cancelled) return;
+        try {
+          const phrase = await fetchPhrase();
+          if (!cancelled && phrase) {
+            appendPhrases([phrase]);
+          }
+        } catch {
+        }
+      }, interval * 2);
+      return () => {
+        cancelled = true;
+        clearInterval(fetchInterval);
+      };
+    }, [fetchPhrase, interval, appendPhrases]);
+    const getAnimationClass = () => {
+      if (animation === "typewriter") return "";
+      const prefix = animation === "blur" ? "nas-blur" : animation === "slide" ? "nas-slide" : "nas-fade";
+      if (isExiting) return `${prefix}-exit`;
+      if (isEntering) return `${prefix}-enter`;
+      return "";
+    };
+    if (animation === "typewriter") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        TypewriterRenderer,
+        {
+          ref,
+          className: cn(notASpinnerVariants({ size, animation }), className),
+          currentPhrase,
+          interval,
+          dots,
+          ...props
+        }
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+      "div",
+      {
+        ref,
+        className: cn(notASpinnerVariants({ size, animation }), className),
+        ...props,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "nas-text-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: getAnimationClass(), children: currentPhrase }) }),
+          dots && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "nas-dots", children: "..." })
+        ]
+      }
+    );
+  }
+);
+NotASpinner.displayName = "NotASpinner";
+var TypewriterRenderer = React.forwardRef(({ className, currentPhrase, interval, dots, ...props }, ref) => {
+  const [displayedChars, setDisplayedChars] = React.useState(0);
+  const [phase, setPhase] = React.useState(
+    "typing"
+  );
+  const phraseRef = React.useRef(currentPhrase);
+  React.useEffect(() => {
+    phraseRef.current = currentPhrase;
+    setDisplayedChars(0);
+    setPhase("typing");
+  }, [currentPhrase]);
+  React.useEffect(() => {
+    const totalChars = phraseRef.current.length;
+    if (totalChars === 0) return;
+    const typingSpeed = 50;
+    const erasingSpeed = 30;
+    const typingDuration = totalChars * typingSpeed;
+    const erasingDuration = totalChars * erasingSpeed;
+    const holdDuration = Math.max(interval - typingDuration - erasingDuration, 500);
+    let timer;
+    if (phase === "typing") {
+      if (displayedChars < totalChars) {
+        timer = setTimeout(() => setDisplayedChars((c) => c + 1), typingSpeed);
+      } else {
+        timer = setTimeout(() => setPhase("holding"), 0);
+      }
+    } else if (phase === "holding") {
+      timer = setTimeout(() => setPhase("erasing"), holdDuration);
+    } else if (phase === "erasing") {
+      if (displayedChars > 0) {
+        timer = setTimeout(() => setDisplayedChars((c) => c - 1), erasingSpeed);
+      }
+    }
+    return () => clearTimeout(timer);
+  }, [phase, displayedChars, interval]);
+  const displayedText = phraseRef.current.slice(0, displayedChars);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { ref, className, ...props, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "nas-text-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+      displayedText,
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "nas-cursor" })
+    ] }) }),
+    dots && displayedChars > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "nas-dots", children: "..." })
+  ] });
+});
+TypewriterRenderer.displayName = "TypewriterRenderer";
+
+// src/providers.ts
+function createAnthropicFetcher(endpoint, locale = "en") {
+  return async () => {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ provider: "anthropic", locale })
+    });
+    if (!res.ok) throw new Error(`Failed to fetch phrase: ${res.status}`);
+    const data = await res.json();
+    return data.phrase;
+  };
+}
+function createOpenAIFetcher(endpoint, locale = "en") {
+  return async () => {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ provider: "openai", locale })
+    });
+    if (!res.ok) throw new Error(`Failed to fetch phrase: ${res.status}`);
+    const data = await res.json();
+    return data.phrase;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotASpinner,
+  cn,
+  createAnthropicFetcher,
+  createOpenAIFetcher,
+  getPhrasesForConfig,
+  notASpinnerVariants,
+  phrases,
+  shufflePhrases,
+  useTextRotation
+});

package/dist/index.d.cts

@@ -0,0 +1,39 @@
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { L as Locale } from './phrases-Dvrk5dm5.cjs';
+export { g as getPhrasesForConfig, p as phrases, s as shufflePhrases } from './phrases-Dvrk5dm5.cjs';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare const notASpinnerVariants: (props?: ({
+    size?: "sm" | "default" | "lg" | null | undefined;
+    animation?: "fade" | "typewriter" | "slide" | "blur" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface NotASpinnerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof notASpinnerVariants> {
+    messages?: string[];
+    locale?: Locale;
+    fetchPhrase?: () => Promise<string>;
+    interval?: number;
+    dots?: boolean;
+}
+declare const NotASpinner: React.ForwardRefExoticComponent<NotASpinnerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface UseTextRotationOptions {
+    phrases: string[];
+    interval?: number;
+    animationDuration?: number;
+}
+interface UseTextRotationReturn {
+    currentPhrase: string;
+    isExiting: boolean;
+    isEntering: boolean;
+    appendPhrases: (newPhrases: string[]) => void;
+}
+declare function useTextRotation({ phrases: inputPhrases, interval, animationDuration, }: UseTextRotationOptions): UseTextRotationReturn;
+
+declare function createAnthropicFetcher(endpoint: string, locale?: string): () => Promise<string>;
+declare function createOpenAIFetcher(endpoint: string, locale?: string): () => Promise<string>;
+
+export { Locale, NotASpinner, type NotASpinnerProps, cn, createAnthropicFetcher, createOpenAIFetcher, notASpinnerVariants, useTextRotation };

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { ClassValue } from 'clsx';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { L as Locale } from './phrases-Dvrk5dm5.js';
+export { g as getPhrasesForConfig, p as phrases, s as shufflePhrases } from './phrases-Dvrk5dm5.js';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare const notASpinnerVariants: (props?: ({
+    size?: "sm" | "default" | "lg" | null | undefined;
+    animation?: "fade" | "typewriter" | "slide" | "blur" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface NotASpinnerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof notASpinnerVariants> {
+    messages?: string[];
+    locale?: Locale;
+    fetchPhrase?: () => Promise<string>;
+    interval?: number;
+    dots?: boolean;
+}
+declare const NotASpinner: React.ForwardRefExoticComponent<NotASpinnerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface UseTextRotationOptions {
+    phrases: string[];
+    interval?: number;
+    animationDuration?: number;
+}
+interface UseTextRotationReturn {
+    currentPhrase: string;
+    isExiting: boolean;
+    isEntering: boolean;
+    appendPhrases: (newPhrases: string[]) => void;
+}
+declare function useTextRotation({ phrases: inputPhrases, interval, animationDuration, }: UseTextRotationOptions): UseTextRotationReturn;
+
+declare function createAnthropicFetcher(endpoint: string, locale?: string): () => Promise<string>;
+declare function createOpenAIFetcher(endpoint: string, locale?: string): () => Promise<string>;
+
+export { Locale, NotASpinner, type NotASpinnerProps, cn, createAnthropicFetcher, createOpenAIFetcher, notASpinnerVariants, useTextRotation };