@ai-matrx/icons 0.1.0

package/dist/index.js

@@ -0,0 +1,686 @@
+"use client";
+
+// src/static-icons.ts
+import {
+  Zap,
+  Home,
+  User,
+  Settings,
+  Search,
+  Bell,
+  Menu,
+  X,
+  ChevronDown,
+  ChevronUp,
+  ChevronLeft,
+  ChevronRight,
+  Plus,
+  Minus,
+  Edit,
+  Trash,
+  Check,
+  AlertCircle,
+  Info,
+  HelpCircle,
+  Eye,
+  EyeOff,
+  Copy,
+  Download,
+  Upload,
+  Save,
+  MoreVertical,
+  MoreHorizontal,
+  Filter,
+  SortAsc,
+  SortDesc,
+  Calendar,
+  Clock,
+  Mail,
+  Phone,
+  MapPin,
+  Link,
+  ExternalLink,
+  File,
+  Folder,
+  Image,
+  Video,
+  Music,
+  FileText,
+  Database,
+  Cloud,
+  Server,
+  Code,
+  Terminal,
+  Globe,
+  Lock,
+  Unlock,
+  Shield,
+  Key,
+  LogIn,
+  LogOut,
+  UserPlus,
+  Users,
+  Star,
+  Heart,
+  Bookmark,
+  Share,
+  Send,
+  MessageSquare,
+  MessageCircle,
+  Hash,
+  AtSign,
+  Paperclip,
+  Mic,
+  Volume2,
+  Play,
+  Pause,
+  SkipForward,
+  SkipBack,
+  RefreshCw,
+  RotateCw,
+  Loader,
+  Loader2,
+  Circle,
+  Square,
+  Triangle,
+  Hexagon,
+  Package,
+  Box,
+  Archive,
+  Inbox,
+  Layers,
+  Layout,
+  Grid,
+  List,
+  Columns,
+  Sidebar,
+  Maximize,
+  Minimize,
+  ZoomIn,
+  ZoomOut,
+  Move,
+  Scissors,
+  Clipboard,
+  PieChart,
+  BarChart,
+  TrendingUp,
+  TrendingDown,
+  Activity,
+  Cpu,
+  HardDrive,
+  Wifi,
+  WifiOff,
+  Bluetooth,
+  Battery,
+  BatteryCharging,
+  Power,
+  Sun,
+  Moon,
+  CloudRain,
+  Droplet,
+  Wind,
+  Tag,
+  Tags,
+  Flag,
+  Award,
+  Gift,
+  ShoppingCart,
+  CreditCard,
+  DollarSign,
+  Percent,
+  Target,
+  Crosshair,
+  Navigation,
+  Compass,
+  Map,
+  Smile,
+  Frown,
+  Meh,
+  ThumbsUp,
+  ThumbsDown
+} from "lucide-react";
+var staticLucideIconMap = {
+  Zap,
+  Home,
+  User,
+  Settings,
+  Search,
+  Bell,
+  Menu,
+  X,
+  ChevronDown,
+  ChevronUp,
+  ChevronLeft,
+  ChevronRight,
+  Plus,
+  Minus,
+  Edit,
+  Trash,
+  Check,
+  AlertCircle,
+  Info,
+  HelpCircle,
+  Eye,
+  EyeOff,
+  Copy,
+  Download,
+  Upload,
+  Save,
+  MoreVertical,
+  MoreHorizontal,
+  Filter,
+  SortAsc,
+  SortDesc,
+  Calendar,
+  Clock,
+  Mail,
+  Phone,
+  MapPin,
+  Link,
+  ExternalLink,
+  File,
+  Folder,
+  Image,
+  Video,
+  Music,
+  FileText,
+  Database,
+  Cloud,
+  Server,
+  Code,
+  Terminal,
+  Globe,
+  Lock,
+  Unlock,
+  Shield,
+  Key,
+  LogIn,
+  LogOut,
+  UserPlus,
+  Users,
+  Star,
+  Heart,
+  Bookmark,
+  Share,
+  Send,
+  MessageSquare,
+  MessageCircle,
+  Hash,
+  AtSign,
+  Paperclip,
+  Mic,
+  Volume2,
+  Play,
+  Pause,
+  SkipForward,
+  SkipBack,
+  RefreshCw,
+  RotateCw,
+  Loader,
+  Loader2,
+  Circle,
+  Square,
+  Triangle,
+  Hexagon,
+  Package,
+  Box,
+  Archive,
+  Inbox,
+  Layers,
+  Layout,
+  Grid,
+  List,
+  Columns,
+  Sidebar,
+  Maximize,
+  Minimize,
+  ZoomIn,
+  ZoomOut,
+  Move,
+  Scissors,
+  Clipboard,
+  PieChart,
+  BarChart,
+  TrendingUp,
+  TrendingDown,
+  Activity,
+  Cpu,
+  HardDrive,
+  Wifi,
+  WifiOff,
+  Bluetooth,
+  Battery,
+  BatteryCharging,
+  Power,
+  Sun,
+  Moon,
+  CloudRain,
+  Droplet,
+  Wind,
+  Tag,
+  Tags,
+  Flag,
+  Award,
+  Gift,
+  ShoppingCart,
+  CreditCard,
+  DollarSign,
+  Percent,
+  Target,
+  Crosshair,
+  Navigation,
+  Compass,
+  Map,
+  Smile,
+  Frown,
+  Meh,
+  ThumbsUp,
+  ThumbsDown
+};
+function extendStaticIcons(map) {
+  Object.assign(staticLucideIconMap, map);
+}
+
+// src/custom-icons.ts
+var CUSTOM_ICON_SOURCES = {
+  FaBrave: "fa6",
+  FcGoogle: "fc",
+  FcBrokenLink: "fc",
+  FcFilm: "fc",
+  FcDownload: "fc",
+  FcBiotech: "fc",
+  FcElectronics: "fc",
+  FcGraduationCap: "fc",
+  FcLibrary: "fc",
+  FcMusic: "fc",
+  FcParallelTasks: "fc",
+  FcSalesPerformance: "fc",
+  FcCalendar: "fc",
+  FcDocument: "fc",
+  FcEngineering: "fc",
+  FcDataProtection: "fc",
+  FcAssistant: "fc",
+  FcSms: "fc",
+  FcTodoList: "fc",
+  FcWikipedia: "fc",
+  FcCommandLine: "fc",
+  FcConferenceCall: "fc",
+  FcManager: "fc",
+  FcAreaChart: "fc",
+  FcMultipleInputs: "fc",
+  FcShipped: "fc",
+  FcBusinessContact: "fc",
+  FcAlphabeticalSortingAz: "fc",
+  FcAlphabeticalSortingZa: "fc",
+  FcFeedback: "fc",
+  FcBusiness: "fc",
+  FcSignature: "fc"
+};
+var customIconCache = {};
+function isCustomIconName(name) {
+  return Object.prototype.hasOwnProperty.call(CUSTOM_ICON_SOURCES, name);
+}
+function listCustomIconNames() {
+  return Object.keys(CUSTOM_ICON_SOURCES);
+}
+async function loadCustomIcon(name) {
+  const cached = customIconCache[name];
+  if (cached) {
+    return cached;
+  }
+  const source = CUSTOM_ICON_SOURCES[name];
+  if (!source) {
+    return null;
+  }
+  try {
+    const mod = source === "fc" ? await import("react-icons/fc") : await import("react-icons/fa6");
+    const exported = mod[name];
+    if (typeof exported !== "function") {
+      return null;
+    }
+    const IconComponent = exported;
+    customIconCache[name] = IconComponent;
+    return IconComponent;
+  } catch {
+    return null;
+  }
+}
+
+// src/svg-registry.ts
+var svgIconRegistry = {};
+var SVG_PREFIX = "svg:";
+function registerSvgIcons(map) {
+  for (const [rawId, path] of Object.entries(map)) {
+    const id = rawId.startsWith(SVG_PREFIX) ? rawId.slice(SVG_PREFIX.length).replace(/^\/+/, "") : rawId.replace(/^\/+/, "");
+    if (id && path) {
+      svgIconRegistry[id] = path;
+    }
+  }
+}
+function parseSvgIconPath(value) {
+  if (!value.startsWith(SVG_PREFIX)) {
+    return null;
+  }
+  const id = value.slice(SVG_PREFIX.length).replace(/^\/+/, "");
+  const path = svgIconRegistry[id];
+  return path ?? null;
+}
+function isSvgIconValue(value) {
+  if (!value || !value.startsWith(SVG_PREFIX)) {
+    return false;
+  }
+  const id = value.slice(SVG_PREFIX.length).replace(/^\/+/, "");
+  return Boolean(svgIconRegistry[id]);
+}
+function listSvgIconValues() {
+  return Object.keys(svgIconRegistry).map((id) => `${SVG_PREFIX}${id}`);
+}
+
+// src/lucide-name-normalize.ts
+function extractLucideJsxIconName(raw) {
+  let s = raw.trim();
+  if (!s) return null;
+  if (s.startsWith("'") && s.endsWith("'") && s.length >= 2 || s.startsWith('"') && s.endsWith('"') && s.length >= 2) {
+    s = s.slice(1, -1).trim();
+  }
+  const m = s.match(/^<\s*([A-Za-z][A-Za-z0-9]*)(?:\s[^>]*)?\s*\/\s*>$/);
+  return m?.[1] ?? null;
+}
+function kebabCaseToLucidePascalCase(raw) {
+  const s = raw.trim();
+  if (!s.includes("-")) {
+    return s;
+  }
+  return s.split("-").filter(Boolean).map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1).toLowerCase()).join("");
+}
+function collectLucideIconNameCandidates(raw) {
+  const t = raw.trim();
+  if (!t) {
+    return [];
+  }
+  const out = [];
+  const push = (s) => {
+    if (s && !out.includes(s)) {
+      out.push(s);
+    }
+  };
+  push(t);
+  if (t[0] === t[0].toLowerCase()) {
+    push(t.charAt(0).toUpperCase() + t.slice(1));
+  }
+  if (t.includes("-")) {
+    push(kebabCaseToLucidePascalCase(t));
+    const lower = t.toLowerCase();
+    if (lower !== t) {
+      push(kebabCaseToLucidePascalCase(lower));
+    }
+  }
+  return out;
+}
+
+// src/lucide-module-icon.ts
+var LUCIDE_NAMESPACE_DENYLIST = /* @__PURE__ */ new Set(["default", "createLucideIcon"]);
+function isLucideModuleIconExport(name, exported) {
+  if (!name || LUCIDE_NAMESPACE_DENYLIST.has(name)) return false;
+  if (exported == null) return false;
+  if (typeof exported === "function") return true;
+  if (typeof exported === "object" && "$$typeof" in exported) {
+    return true;
+  }
+  return false;
+}
+
+// src/resolver.tsx
+import { useState, useEffect } from "react";
+
+// src/cn.ts
+function cn(...values) {
+  return values.filter(Boolean).join(" ").trim();
+}
+
+// src/resolver.tsx
+import { jsx } from "react/jsx-runtime";
+var dynamicIconCache = {};
+function getCuratedIconIdsForPicker() {
+  const set = /* @__PURE__ */ new Set();
+  for (const k of Object.keys(staticLucideIconMap)) {
+    set.add(k);
+  }
+  for (const k of listCustomIconNames()) {
+    set.add(k);
+  }
+  for (const id of listSvgIconValues()) {
+    set.add(id);
+  }
+  return Array.from(set).sort(
+    (a, b) => a.localeCompare(b, void 0, { sensitivity: "base" })
+  );
+}
+function isIconRegisteredSync(iconName) {
+  if (!iconName || iconName.trim() === "") {
+    return false;
+  }
+  const name = iconName;
+  if (isCustomIconName(name)) return true;
+  if (staticLucideIconMap[name]) return true;
+  return Boolean(dynamicIconCache[name]);
+}
+async function isRegisteredOrLucideIconName(iconName) {
+  if (!iconName || iconName.trim() === "") {
+    return false;
+  }
+  if (isSvgIconValue(iconName)) {
+    return true;
+  }
+  if (isIconRegisteredSync(iconName)) {
+    return true;
+  }
+  try {
+    const iconModule = await import("lucide-react");
+    const Exported = iconModule[iconName];
+    return isLucideModuleIconExport(iconName, Exported);
+  } catch {
+    return false;
+  }
+}
+var IconResolver = ({
+  iconName,
+  className = "h-4 w-4",
+  size,
+  fallbackIcon = "Zap",
+  style
+}) => {
+  const svgSrc = iconName ? parseSvgIconPath(iconName) : null;
+  const [DynamicIcon2, setDynamicIcon] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  useEffect(() => {
+    const loadIcon = async () => {
+      if (!iconName) {
+        setDynamicIcon(null);
+        setIsLoading(false);
+        return;
+      }
+      if (parseSvgIconPath(iconName)) {
+        setDynamicIcon(null);
+        setIsLoading(false);
+        return;
+      }
+      const cachedCustom = customIconCache[iconName];
+      if (cachedCustom) {
+        setDynamicIcon(() => cachedCustom);
+        return;
+      }
+      const staticIcon = staticLucideIconMap[iconName];
+      if (staticIcon) {
+        setDynamicIcon(() => staticIcon);
+        return;
+      }
+      const cachedDynamic = dynamicIconCache[iconName];
+      if (cachedDynamic) {
+        setDynamicIcon(() => cachedDynamic);
+        return;
+      }
+      if (isCustomIconName(iconName)) {
+        setIsLoading(true);
+        const loaded = await loadCustomIcon(iconName);
+        if (loaded) {
+          setDynamicIcon(() => loaded);
+        } else {
+          setDynamicIcon(() => staticLucideIconMap[fallbackIcon] || Zap);
+        }
+        setIsLoading(false);
+        return;
+      }
+      setIsLoading(true);
+      try {
+        const iconModule = await import("lucide-react");
+        const exported = iconModule[iconName];
+        if (isLucideModuleIconExport(iconName, exported)) {
+          const IconComponent2 = exported;
+          dynamicIconCache[iconName] = IconComponent2;
+          setDynamicIcon(() => IconComponent2);
+        } else {
+          setDynamicIcon(() => staticLucideIconMap[fallbackIcon] || Zap);
+        }
+      } catch (error) {
+        console.warn(`Failed to load icon: ${iconName}`, error);
+        setDynamicIcon(() => staticLucideIconMap[fallbackIcon] || Zap);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    loadIcon();
+  }, [iconName, fallbackIcon]);
+  if (svgSrc) {
+    return /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: svgSrc,
+        alt: "",
+        className: cn("object-contain shrink-0", className),
+        width: size,
+        height: size,
+        style
+      }
+    );
+  }
+  const IconComponent = DynamicIcon2 || staticLucideIconMap[fallbackIcon] || Zap;
+  const iconProps = {
+    ...className !== void 0 ? { className } : {},
+    ...size !== void 0 ? { size } : {},
+    ...style !== void 0 ? { style } : {}
+  };
+  if (isLoading && !DynamicIcon2) {
+    const FallbackIcon = staticLucideIconMap[fallbackIcon] || Zap;
+    return /* @__PURE__ */ jsx(FallbackIcon, { ...iconProps });
+  }
+  return /* @__PURE__ */ jsx(IconComponent, { ...iconProps });
+};
+var resolver_default = IconResolver;
+var getIconComponent = (iconName, fallbackIcon = "Zap") => {
+  if (!iconName) {
+    return staticLucideIconMap[fallbackIcon] || Zap;
+  }
+  const custom = customIconCache[iconName];
+  if (custom) {
+    return custom;
+  }
+  const staticIcon = staticLucideIconMap[iconName];
+  if (staticIcon) {
+    return staticIcon;
+  }
+  const dynamic = dynamicIconCache[iconName];
+  if (dynamic) {
+    return dynamic;
+  }
+  return staticLucideIconMap[fallbackIcon] || Zap;
+};
+var renderIcon = (iconName, props, fallbackIcon = "Zap") => {
+  const IconComponent = getIconComponent(iconName, fallbackIcon);
+  return /* @__PURE__ */ jsx(IconComponent, { ...props });
+};
+var isHexColor = (color) => {
+  return /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(color);
+};
+var getTextColorClass = (color) => {
+  if (!color) return "text-gray-600 dark:text-gray-400";
+  if (isHexColor(color)) return null;
+  const colorMap = {
+    gray: "text-gray-600 dark:text-gray-400",
+    rose: "text-rose-600 dark:text-rose-400",
+    blue: "text-blue-600 dark:text-blue-400",
+    amber: "text-amber-600 dark:text-amber-400",
+    cyan: "text-cyan-600 dark:text-cyan-400",
+    emerald: "text-emerald-600 dark:text-emerald-400",
+    fuchsia: "text-fuchsia-600 dark:text-fuchsia-400",
+    green: "text-green-600 dark:text-green-400",
+    indigo: "text-indigo-600 dark:text-indigo-400",
+    lime: "text-lime-600 dark:text-lime-400",
+    neutral: "text-neutral-600 dark:text-neutral-400",
+    orange: "text-orange-600 dark:text-orange-400",
+    pink: "text-pink-600 dark:text-pink-400",
+    purple: "text-purple-600 dark:text-purple-400",
+    red: "text-red-600 dark:text-red-400",
+    sky: "text-sky-600 dark:text-sky-400",
+    slate: "text-slate-600 dark:text-slate-400",
+    stone: "text-stone-600 dark:text-stone-400",
+    teal: "text-teal-600 dark:text-teal-400",
+    violet: "text-violet-600 dark:text-violet-400",
+    yellow: "text-yellow-600 dark:text-yellow-400",
+    zinc: "text-zinc-600 dark:text-zinc-400"
+  };
+  return colorMap[color.toLowerCase()] || "text-gray-600 dark:text-gray-400";
+};
+var getIconWithColorAndSize = (iconName, color = "gray", size = 4) => {
+  const IconComponent = getIconComponent(iconName);
+  const colorClass = getTextColorClass(color);
+  return /* @__PURE__ */ jsx(IconComponent, { className: `h-${size} w-${size} ${colorClass}` });
+};
+var DynamicIcon = ({
+  name,
+  color = "gray",
+  size = 4,
+  className,
+  fallbackIcon = "Zap"
+}) => {
+  const isHex = color && isHexColor(color);
+  const colorClass = isHex ? null : getTextColorClass(color);
+  const sizeClass = `h-${size} w-${size}`;
+  const combinedClassName = [sizeClass, !isHex && colorClass, className].filter(Boolean).join(" ").trim();
+  const style = isHex ? { color } : void 0;
+  return /* @__PURE__ */ jsx(
+    IconResolver,
+    {
+      iconName: name,
+      className: combinedClassName,
+      fallbackIcon,
+      style
+    }
+  );
+};
+export {
+  DynamicIcon,
+  resolver_default as IconResolver,
+  collectLucideIconNameCandidates,
+  extendStaticIcons,
+  extractLucideJsxIconName,
+  getCuratedIconIdsForPicker,
+  getIconComponent,
+  getIconWithColorAndSize,
+  getTextColorClass,
+  isCustomIconName,
+  isHexColor,
+  isIconRegisteredSync,
+  isLucideModuleIconExport,
+  isRegisteredOrLucideIconName,
+  isSvgIconValue,
+  kebabCaseToLucidePascalCase,
+  listCustomIconNames,
+  listSvgIconValues,
+  loadCustomIcon,
+  parseSvgIconPath,
+  registerSvgIcons,
+  renderIcon,
+  staticLucideIconMap
+};
+//# sourceMappingURL=index.js.map