DEV Community: pjdev2d

md - context menu

pjdev2d — Tue, 26 May 2026 08:07:38 +0000

# Context Menu System – Architecture Review Notes

## Current Architecture Score

| Area | Score |
|-------|-------|
| Architecture | 8.5 / 10 |
| Correctness | 8 / 10 |
| Production Readiness | 6.5 / 10 |

---

# Issue 1 — Hover Gap Flicker

## Problem

Current implementation:

tsx
onMouseEnter(() => setIsOpen(true))
onMouseLeave(() => setIsOpen(false))


Scenario:

Export >
moving mouse
↓
gap between parent and submenu
↓
submenu closes unexpectedly


This creates unstable submenu UX.

Production desktop applications avoid this.

---

## Solution

Use Floating UI interaction hooks:

tsx
useHover()
safePolygon()


Future direction:

tsx
useHover(context,{
handleClose:safePolygon()
})


Benefits:

- Prevent submenu closing while cursor moves
- Better hover experience
- Desktop application quality interactions

Priority: HIGH

---

# Issue 2 — Nested Submenu Limitation

## Problem

Current rendering supports:

Export >
PDF
CSV


But fails for:

Export >
CSV >
Daily
Monthly


Current renderer only handles one submenu level.

---

## Solution

Convert submenu rendering into recursive rendering.

Future architecture:

SubMenuItem
└── SubMenuItem
└── SubMenuItem
└── Infinite levels


Benefits:

- Unlimited submenu nesting
- Cleaner architecture
- Better scalability

Priority: HIGH

---

# Issue 3 — Missing Size Middleware

## Problem

Current middleware:

ts
middleware:[
offset(),
flip(),
shift()
]


Large menus can overflow viewport.

Example:

200 menu items
↓
menu exceeds viewport height


Current system does not control menu sizing.

---

## Solution

Add Floating UI:

tsx
size()


Example direction:

tsx
size({
apply({
availableHeight,
elements
}){
Object.assign(
elements.floating.style,
{
maxHeight:
${availableHeight}px
}
)
}
})


Benefits:

- Dynamic max height
- Automatic scrolling
- Better viewport handling

Priority: MEDIUM

---

# Issue 4 — Floating Logic Duplication

## Problem

Current system:

SubMenuItem

RenderRightClickMenu


Both know positioning internals.

Future additions:

Tooltip
Hover Card
Dropdown
Command Menu


May duplicate Floating UI logic.

---

## Solution

Create shared floating abstraction.

Future architecture:

floating-layer/

useFloatingLayer()

context-menu/

tooltip/

hover-card/

dropdown/


Benefits:

- Single positioning engine
- Shared collision handling
- Easier maintenance
- Cleaner architecture

Priority: MEDIUM

---

# Issue 5 — Possible Redundant Update Calls

## Problem

Current implementation:

tsx
update()


inside:

tsx
useEffect()


Current system already uses:

tsx
autoUpdate()


Manual updates may create unnecessary work.

---

## Solution

Validate whether manual update calls are required.

Keep only if measurements prove necessary.

Benefits:

- Less work per render
- Cleaner Floating UI integration

Priority: LOW

---

# Recommended Upgrade Order

1. safePolygon hover handling

2. Recursive submenu rendering

3. Floating UI size middleware

4. Shared floating abstraction

---

# Future Architecture Goal

Final architecture target:

Interaction Layer
↓

Context Resolution Layer
(Base > Page > Element)

↓

Menu Resolution Layer

↓

Floating Layer Engine

↓

Context Menu
Tooltip
Hover Card
Dropdown
Quick Actions
Command Palette


Single positioning system.

Multiple UI consumers.

---

# Future AI Prompt

Review my React + Floating UI context menu architecture as a senior frontend architect with 10+ years experience.

Analyze:

- scalability
- collision detection
- submenu behavior
- hover interactions
- recursive rendering capability
- viewport handling
- edge collision detection
- Floating UI middleware usage
- abstraction quality
- state architecture
- performance concerns
- accessibility considerations
- maintainability
- production readiness

Identify:

- architectural weaknesses
- UX issues
- performance bottlenecks
- missing production features

Provide:

- priority ordering
- production-grade improvements
- future scalability recommendations

Avoid beginner suggestions and review like a senior frontend architect building desktop-quality web applications.

pagination

pjdev2d — Mon, 25 May 2026 14:29:57 +0000

import { useState } from "react";

export function usePagination(initialPage = 1) {
  const [page, setPage] = useState(initialPage);

  const nextPage = () => {
    setPage((prev) => prev + 1);
  };

  const prevPage = () => {
    setPage((prev) => Math.max(prev - 1, 1));
  };

  return {
    page,
    setPage,
    nextPage,
    prevPage,
  };
}


/* 

const pagination = usePagination();

const { data } = useUsers({
  page: pagination.page,
});


<Pagination
  page={pagination.page}
  totalPages={data.meta.totalPages}
  onNext={pagination.nextPage}
  onPrev={pagination.prevPage}
/>

*/

types

export interface PaginationProps {
  page: number;
  totalPages: number;

  onNext: () => void;
  onPrev: () => void;
}

pagination.tsx

import { ChevronLeft, ChevronRight } from "lucide-react";
import type { PaginationProps } from "./types";

export function Pagination({
  page,
  totalPages,
  onNext,
  onPrev,
}: PaginationProps) {
  const isFirstPage = page <= 1;
  const isLastPage = page >= totalPages;

  return (
    <div className="flex justify-end items-center gap-3">
      <button
        type="button"
        onClick={onPrev}
        disabled={isFirstPage}
        className="flex justify-center items-center disabled:opacity-50 border rounded-md w-9 h-9 disabled:cursor-not-allowed"
      >
        <ChevronLeft size={18} />
      </button>

      <p className="text-sm">
        Page {page} of {totalPages}
      </p>

      <button
        type="button"
        onClick={onNext}
        disabled={isLastPage}
        className="flex justify-center items-center disabled:opacity-50 border rounded-md w-9 h-9 disabled:cursor-not-allowed"
      >
        <ChevronRight size={18} />
      </button>
    </div>
  );
}

notify

pjdev2d — Mon, 25 May 2026 12:51:30 +0000

constants

import type { NotifyPosition, NotifyVariant } from "./types";

export const notifyPositionClasses: Record<NotifyPosition, string> = {
  "top-left": "top-4 left-4",
  "top-center": "top-4 left-1/2 -translate-x-1/2",
  "top-right": "top-4 right-4",
  "bottom-left": "bottom-4 left-4",
  "bottom-center": "bottom-4 left-1/2 -translate-x-1/2",
  "bottom-right": "bottom-4 right-4",
};

export const notifyVariantClasses: Record<NotifyVariant, string> = {
  default: "border-neutral-200 bg-white text-black",

  success: "border-green-200 bg-green-50 text-green-950",

  error: "border-red-200 bg-red-50 text-red-950",

  warning: "border-yellow-200 bg-yellow-50 text-yellow-950",

  info: "border-blue-200 bg-blue-50 text-blue-950",
};

INDEX

export { NotifyContainer } from "./notify-container";
export { notify, dismiss } from "./store";

card

import { dismiss } from "./store";
import type { NotifyItem } from "./types";
import { notifyVariantClasses } from "./constants";
import { cn } from "@/src/utils";

interface NotifyCardProps {
  item: NotifyItem;
}

export function NotifyCard({ item }: NotifyCardProps) {
  return (
    <div
      className={cn(
        "shadow-xl p-4 border rounded-xl min-w-[320px]",
        notifyVariantClasses[item?.variant || "default"],
      )}
    >
      <div className="flex justify-between items-start gap-4">
        <div>
          {item.title && <h3 className="font-semibold">{item.title}</h3>}

          {item.description && (
            <p className="text-neutral-500 text-sm">{item.description}</p>
          )}
        </div>

        <button onClick={() => dismiss()}>✕</button>
      </div>
    </div>
  );
}

container

import { useEffect, useState } from "react";
import type { NotifyItem } from "./types";
import { subscribe } from "./store";
import { notifyPositionClasses } from "./constants";
import { cn } from "@/src/utils";
import { NotifyCard } from "./notify-card";
import { Potral } from "../overlay";

export function NotifyContainer() {
  const [item, setItem] = useState<NotifyItem | null>(null);
  const [visible, setVisible] = useState(false);
  const [renderItem, setRenderItem] = useState<NotifyItem | null>(null);

  useEffect(() => {
    return subscribe(setItem);
  }, []);

  useEffect(() => {
    if (item) {
      setRenderItem(item);

      requestAnimationFrame(() => {
        setVisible(true);
      });
    } else {
      setVisible(false);

      const timeout = setTimeout(() => {
        setRenderItem(null);
      }, 300);

      return () => clearTimeout(timeout);
    }
  }, [item]);

  if (!renderItem) return null;

  return (
    <Potral>
      <div
        key={renderItem.id}
        className={cn(
          "z-[9999] fixed transition-all duration-300",
          visible ? "translate-y-0 opacity-100" : "-translate-y-2 opacity-0",
          notifyPositionClasses[renderItem.position || "top-center"],
        )}
      >
        <NotifyCard item={renderItem} />
      </div>
    </Potral>
  );
}

Store

import type { NotifyItem } from "./types";

type Listener = (item: NotifyItem | null) => void;
let memoryState: NotifyItem | null = null;
let listener: Listener | null = null;

function dispatch() {
  listener?.(memoryState);
}

export function subscribe(l: Listener) {
  listener = l;

  listener(memoryState);

  return () => {
    listener = null;
  };
}

export function notify(item: Omit<NotifyItem, "id">) {
  const newItem: NotifyItem = {
    id: crypto.randomUUID(),
    ...item,
  };

  memoryState = newItem;

  dispatch();

  return newItem.id;
}

export function dismiss() {
  memoryState = null;

  dispatch();
}

types

export type NotifyPosition =
  | "top-left"
  | "top-center"
  | "top-right"
  | "bottom-left"
  | "bottom-center"
  | "bottom-right";

export type NotifyVariant =
  | "default"
  | "success"
  | "error"
  | "info"
  | "warning";

export interface NotifyItem {
  id: string;
  title?: string;
  description?: string;
  position?: NotifyPosition;
  variant?: NotifyVariant;
}

calling

import { RouterProvider } from "react-router-dom";
import { router } from "./router";
import { NotifyContainer, ToastContainer } from "./components/base";

function App() {
  return (
    <>
      <RouterProvider router={router} />
      <ToastContainer />
      <NotifyContainer />
    </>
  );
}

export default App;

app provider

pjdev2d — Fri, 22 May 2026 08:29:08 +0000

import type { Provider as Props } from "@/root.config";
import { createContext, useContext, useState } from "react";
import { Modal, SidePanel } from "../components/base";
import { APP_PROVIDER_TYPE } from "../utils";

const AppContext = createContext<Props.AppContextProps | undefined>(undefined);
export const AppProvider = ({ children }: Props.ProviderProps) => {
  const [stack, setStack] = useState<
    {
      id: Props.BaseProps["id"];
      type: Props.BaseProps["type"];
      content?: Props.BaseProps["providerContent"];
      options?: Props.BaseProps["options"];
    }[]
  >([]);

  const open = (
    type: Props.BaseProps["type"],
    content?: Props.BaseProps["providerContent"],
    options?: Props.BaseProps["options"],
  ) => {
    const id = Math.random().toString();
    setStack((prev) => [...prev, { id, type, content, options }]);
  };
  const close = (id: Props.BaseProps["id"]) => {
    setStack((prev) => prev.filter((i) => i.id !== id));
  };

  return (
    <AppContext.Provider value={{ open, close }}>
      {children}
      {stack.map((item) => (
        <div key={item.id}>
          {item.type === APP_PROVIDER_TYPE.MODAL && (
            <Modal options={item.options || {}} onClose={() => close(item.id)}>
              {item.content &&
                item.content({
                  close: () => close(item.id),
                })}
            </Modal>
          )}
          {item.type === APP_PROVIDER_TYPE.SIDE_PANEL && (
            <SidePanel
              options={item.options || {}}
              onClose={() => close(item.id)}
            >
              {item.content?.({
                close: () => close(item.id),
              })}
            </SidePanel>
          )}
        </div>
      ))}
    </AppContext.Provider>
  );
};

export const useAppProvider = () => {
  const context = useContext(AppContext);
  if (!context) throw new Error("useApp must be used within AppProviders");
  return context;
};

MAIN

  <StrictMode>
    <AppProvider>
      <App />
    </AppProvider>
  </StrictMode>,

INTERFACE

import { type ReactNode } from "react";

export namespace Provider {
  export interface BaseProps {
    children: ReactNode;
    id: string;
    type: string;
    content: ReactNode;
    custom: () => ReactNode;
    providerContent: (helpers: { close: () => void }) => ReactNode;
    options?: {
      [key: string]: unknown;
      onSide?: "left" | "right" | undefined;
    };
  }
  export interface AppContextProps {
    open: (
      type: BaseProps["type"],
      content?: BaseProps["providerContent"],
      options?: BaseProps["options"],
    ) => void;
    close: (id: BaseProps["id"]) => void;
  }
  export interface ProviderProps {
    children: BaseProps["children"];
  }
}

modals

pjdev2d — Fri, 22 May 2026 08:27:24 +0000

import { X } from "lucide-react";
import { Btn } from "./button";
import { Flex } from "./layout";
import { cn } from "@/src/utils";

interface Props {
  children: React.ReactNode;
  className?: string;
  title?: string;
  description?: string;
  footer?: React.ReactNode;
  close?: () => void;
}
export function ModalCard({
  children,
  title,
  description,
  footer,
  className,
  close,
}: Props) {
  return (
    <Flex
      direction="column"
      className={cn(
        " bg-white max-h-[90vh] max-w-[90vw] rounded-xl overflow-hidden",
        className,
      )}
    >
      <Flex
        direction="row"
        items="center"
        justify="between"
        className="w-full p-4 border-b"
      >
        <Flex direction="column">
          {title && <span className="font-semibold">{title}</span>}
          {description && <span>{description}</span>}
        </Flex>
        <Btn variant="solid-icon" rounded="full" onClick={close}>
          <X strokeWidth={2.5} />
        </Btn>
      </Flex>

      <div className="w-full min-w-0 overflow-auto p-4">{children}</div>

      <div className="flex justify-end w-full p-4 border-t">{footer}</div>
    </Flex>
  );
}

modal

import { Backdrop } from "./backdrop";
import { type Provider as Props } from "@/root.config";
import { Potral } from "./portal";

interface ModalBaseProps {
  children?: Props.BaseProps["children"];
  onClose?: () => void;
  options: Props.BaseProps["options"];
}

export const Modal = ({ children, onClose, options }: ModalBaseProps) => {
  return (
    <Potral>
      <Backdrop {...options} onClose={onClose}>
        <div className="relative z-10000">{children}</div>
      </Backdrop>
    </Potral>
  );
};

import { X } from "lucide-react";
import { Btn } from "./button";
import { Flex } from "./layout";
import { cn } from "@/src/utils";

interface Props {
  children: React.ReactNode;
  title?: string;
  description?: string;
  className?: string;
  close?: () => void;
}
export function SidePanelCard({
  children,
  title,
  description,
  className,
  close,
}: Props) {
  return (
    <Flex
      direction="column"
      className={cn(
        " bg-white min-h-screen min-w-10 overflow-hidden",
        className,
      )}
    >
      <Flex
        direction="row"
        items="center"
        justify="between"
        className="w-full p-4 border-b"
      >
        <Flex direction="column">
          {title && <span className="font-semibold">{title}</span>}
          {description && <span>{description}</span>}
        </Flex>
        <Btn variant="solid-icon" rounded="full" onClick={close}>
          <X strokeWidth={2.5} />
        </Btn>
      </Flex>

      <Flex direction="row" className="min-h-0 w-auto overflow-y-auto p-4">
        {children}
      </Flex>
    </Flex>
  );
}

sidepanel

import type { ReactNode } from "react";
import { Backdrop } from "./backdrop";
import { type Provider as Props } from "@/root.config";
import { Potral } from "./portal";

interface SidePanelBaseProps {
  children?: ReactNode | string;
  onClose?: () => void;
  options: Props.BaseProps["options"];
}

export function SidePanel({ children, onClose, options }: SidePanelBaseProps) {
  const justify = options?.onSide === "left" ? "start" : "end";
  return (
    <>
      <Potral>
        <Backdrop justify={justify} onClose={() => onClose?.()}>
          <div className="relative z-10000">{children}</div>
        </Backdrop>
      </Potral>
    </>
  );
}

callings

export const Dashboard = () => {
  const { open } = useAppProvider();

  const handleOpenModal = () => {
    open(APP_PROVIDER_TYPE.MODAL, ({ close }) => (
      <ModalCard close={close}> this is modal</ModalCard>
    ));
  };

  const handleOpenSidepanel = () => {
    open(APP_PROVIDER_TYPE.SIDE_PANEL, ({ close }) => (
      <SidePanelCard close={close}>this is side panel</SidePanelCard>
    ));
  };

  return (
    <>
      <Btn
        onClick={() => handleOpenModal()}
        variant="solid"
        className="px-4 py-2 text-sm rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 transition"
      >
        Trigger Global Modal
      </Btn>

      <Btn
        onClick={handleOpenSidepanel}
        variant="solid"
        className="px-4 py-2 text-sm rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 transition"
      >
        Trigger Global Sidepanel
      </Btn>
    </>
  );
};

sidepanel

pjdev2d — Thu, 21 May 2026 13:29:55 +0000

 const handleOpenSidepanel = () => {
    open(APP_PROVIDER_TYPE.sidepanel, ({ close }) => (
      <div className="w-96">
        <Btn
          onClick={close}
          variant="outline"
          className="px-4 py-2 text-sm rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 transition"
        >
          Cancel
        </Btn>
      </div>
    ));
  };
 <Btn
        onClick={handleOpenSidepanel}
        variant="solid"
        className="px-4 py-2 text-sm rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 transition"
      >
        Trigger Global Sidepanel
      </Btn>

other

 {item.type === APP_PROVIDER_TYPE.sidepanel && (
            <SidePanel
              options={item.options || {}}
              onClose={() => close(item.id)}
            >
              {item.content({
                close: () => close(item.id),
              })}
            </SidePanel>
          )}

import type { ReactNode } from "react";
import { Backdrop } from "./backdrop";
import { type Provider as Props } from "@/root.config";
import { Potral } from "./portal";
import { Flex } from "../layout";

interface SidePanelBaseProps {
  children?: ReactNode | string;
  onClose?: () => void;
  options: Props.BaseProps["options"];
}

export function SidePanel({ children, onClose, options }: SidePanelBaseProps) {
  return (
    <>
      <Potral>
        <Backdrop justify="end" {...options} onClose={() => onClose?.()}>
          <Flex
            direction="column"
            justify="start"
            items="center"
            className="bg-white h-full relative w-fit"
          >
            {children}
          </Flex>
        </Backdrop>
      </Potral>
    </>
  );
}

Flow of modal context

pjdev2d — Thu, 21 May 2026 08:11:41 +0000

create btn (any where)

 <Btn onClick={handleOpenModal} variant="solid"> Open Modal </Btn>

handleOpenModal => contains the code of main component we will pass

provider_type
(close)=>(react node main)
options{}

now call

    const { open } = useAppProvider();

we only have open because we already passing close in modal

AppProvider => contains the main code of provider so that it can be called anywhere

 <AppContext.Provider value={{ open, close }}>
      {children}
      {stack.map((item) => (
        <div key={item.id}>
          {item.type === APP_PROVIDER_TYPE.modal && (
            <Modal options={item.options || {}} onClose={() => close(item.id)}>
              {item.content({
                close: () => close(item.id),
              })}
            </Modal>
          )}
          {/* You can add PANEL here later! */}
        </div>
      ))}
    </AppContext.Provider>

this modal comp is the main comp which contains the actual react node

export const Modal = ({ children, onClose, options }: ModalBaseProps) => {
  return (
    <Potral>
      <Backdrop {...options} onClose={onClose}>
        {children}
      </Backdrop>
    </Potral>
  );
};

potral here will potral the actual content at the bottom of code seperately and backdrop is just another comp that creates a backdrop screen in which main content will render

R Learning

pjdev2d — Wed, 20 May 2026 10:37:15 +0000

React Core Concepts Roadmap

If you want to become genuinely strong in React, focus less on “learning more libraries” and more on mastering the core concepts deeply.

These are the concepts that actually matter.

1. Components & Composition

The foundation of React.

Understand:

reusable components
props
composition patterns
controlled vs uncontrolled components
lifting state up

Core mindset:

Small reusable pieces > giant components

This is one of the biggest differences between beginner and advanced React code.

2. State Management

You must deeply understand:

local state
derived state
shared state
server state

And especially:

Not everything should go into state

A huge beginner mistake is overusing state.

3. Rendering Behavior

This is SUPER important.

Learn:

what causes rerenders
parent/child rerenders
reconciliation
React rendering cycle
batching
render vs commit phase

This knowledge explains:

performance issues
weird UI behavior
unnecessary rerenders

4. Hooks Deeply

Not just syntax.

Really understand:

useState
useEffect
useMemo
useCallback
useRef
useContext

Especially:

useEffect

Most React bugs come from misunderstanding effects.

Learn:

dependency arrays
stale closures
cleanup functions
synchronization mindset

5. Server State vs Client State

This is modern React architecture.

Understand difference between:

Client state

UI-only state.

Examples:

modal open
active tab
input value

Server state

Data from backend.

Examples:

users
notifications
products

This leads to tools like:

TanStack Query

6. Data Fetching & Caching

One of the most important modern skills.

Learn:

fetching lifecycle
loading states
background refetching
optimistic updates
cache invalidation
stale data
retries

This becomes critical in real apps.

7. React Architecture

Learn how to structure apps.

Understand:

folder structure
separation of concerns
reusable patterns
feature-based architecture
UI vs business logic

This matters more than fancy libraries.

8. Forms

Forms are deceptively difficult.

Learn:

controlled inputs
validation
async submit handling
optimistic form updates

Eventually:

React Hook Form

9. Async UI Thinking

Modern React is mostly async.

Understand:

promises
race conditions
concurrent requests
request cancellation
optimistic UI
suspense mindset

10. Performance

Very important later.

Learn:

memoization
virtualization
code splitting
lazy loading
avoiding unnecessary renders

But only AFTER understanding rendering deeply.

11. React Mental Model

This is the most important thing.

React is NOT:

"change DOM directly"

React is:

UI = function(state)

You describe UI based on state.

React handles updates.

This mental model changes everything.

12. Thinking in React

Advanced React developers think in:

state flow
data ownership
synchronization
UI transitions
component boundaries

not:

“where do I put this code?”

Biggest milestone in React learning

Beginner React

learns syntax

Intermediate React

builds features

Advanced React

understands rendering and state architecture

Senior React

designs predictable async UI systems

Recommended Learning Order

Components
State
Rendering
Hooks deeply
Async behavior
Server state
Caching
Architecture
Performance
Advanced patterns

What Actually Makes React Hard

Not JSX.

Not hooks syntax.

The hard part is:

managing async state predictably

That’s the real React skill ceiling.

t2 - comp

pjdev2d — Tue, 19 May 2026 07:57:21 +0000

New Comps

card comp
hover card
dropdown menu on click
context menu (right click & btn click)
bread crumbs (clickable / unclickables)
progress bar
custom scroll bar
toggle switch (like bookmark)

Major Comps

Nav menu (position + collaspe + sub meus)
skeleton effect
tab switch
accordin
slider

-- hydration & page reload logic for url params

https://chatgpt.com/share/6a145bce-80c4-83a8-8c57-a5d98cee7140

skeleton

np

pjdev2d — Mon, 18 May 2026 12:36:54 +0000

ChatGPT - Publish NPM Package Steps

Shared via ChatGPT

chatgpt.com

#!/usr/bin/env node

const { Command } = require("commander");
const fs = require("fs-extra");
const path = require("path");
const babel = require("@babel/core");
const presetTypescript = require("@babel/preset-typescript");
const { execSync } = require("child_process");
const registry = require("../registry.json");

const program = new Command();

/* -----------------------------
   INQUIRER (FIXED SAFE WRAPPER)
------------------------------*/
const prompt = async (questions) => {
  const inquirer = await import("inquirer");
  return inquirer.default.prompt(questions);
};

/* =============================
   ADD COMMAND
============================= */
program
  .command("add <name>")
  .description("Add components or utilities")
  .action(async (name) => {
    try {
      const cwd = process.cwd();
      console.log("\n🚀 Starting installation...\n");

      const isTsProject = fs.existsSync(path.join(cwd, "tsconfig.json"));

      let templatePath = "";
      let outputDir = "";
      let extension = "tsx";

      /* ---------------- COMPONENTS ---------------- */
      if (!name.startsWith("utils/")) {
        templatePath = path.join(__dirname, `../templates/${name}.tsx`);
        outputDir = path.join(cwd, "src/components/pejay-ui");
        extension = "tsx";
      } else {

      /* ---------------- UTILITIES ---------------- */
        const utilName = name.split("/")[1];
        templatePath = path.join(__dirname, `../utils/${utilName}.ts`);
        outputDir = path.join(cwd, "src/utils/pejay-ui");
        extension = "ts";
      }

      if (!fs.existsSync(templatePath)) {
        console.log(`❌ "${name}" not found`);
        return;
      }

      const code = await fs.readFile(templatePath, "utf8");

      let finalCode = code;
      let outputExt = extension;

      /* ---------------- TRANSFORM ---------------- */
      if (!isTsProject) {
        const transformed = babel.transformSync(code, {
          presets: [presetTypescript],
          filename: `file.${extension}`,
        });

        if (!transformed?.code) {
          throw new Error("Babel transform failed");
        }

        finalCode = transformed.code;
        outputExt = extension === "tsx" ? "jsx" : "js";
      }

      await fs.ensureDir(outputDir);

      const itemName = name.includes("/") ? name.split("/")[1] : name;
      const outputPath = path.join(outputDir, `${itemName}.${outputExt}`);

      await fs.writeFile(outputPath, finalCode);
      console.log(`✅ Created ${itemName}.${outputExt}`);

      /* ---------------- DEPENDENCIES ---------------- */
      const itemRegistry = registry[name];

      if (itemRegistry?.dependencies?.length) {
        for (const dependency of itemRegistry.dependencies) {
          const depName = dependency.includes("/")
            ? dependency.split("/")[1]
            : dependency;

          const depPath = path.join(__dirname, `../utils/${depName}.ts`);

          if (!fs.existsSync(depPath)) continue;

          let depCode = await fs.readFile(depPath, "utf8");

          if (!isTsProject) {
            const transformed = babel.transformSync(depCode, {
              presets: [presetTypescript],
              filename: `${depName}.ts`,
            });

            depCode = transformed.code;
          }

          const utilDir = path.join(cwd, "src/utils/pejay-ui");
          await fs.ensureDir(utilDir);

          const ext = isTsProject ? "ts" : "js";
          const outPath = path.join(utilDir, `${depName}.${ext}`);

          if (!fs.existsSync(outPath)) {
            await fs.writeFile(outPath, depCode);
            console.log(`📦 Added dependency ${depName}`);
          }
        }
      }

      /* ---------------- STATE SAVE ---------------- */
      const statePath = path.join(cwd, ".pejay-ui.json");

      let state = {};
      if (fs.existsSync(statePath)) {
        state = JSON.parse(await fs.readFile(statePath, "utf8"));
      }

      state.installed = state.installed || {};

      state.installed[name] = {
        files: [`src/components/pejay-ui/${itemName}.${outputExt}`],
        uses:
          itemRegistry?.dependencies?.map((d) =>
            d.includes("/") ? d.split("/")[1] : d,
          ) || [],
      };

      await fs.writeFile(statePath, JSON.stringify(state, null, 2));

      console.log(`\n🎉 ${name} installed successfully\n`);
    } catch (err) {
      console.error("\n❌ Add failed\n", err);
    }
  });

/* =============================
   REMOVE COMMAND (SAFE VERSION)
============================= */
program
  .command("remove <name>")
  .description("Remove components or utilities safely")
  .action(async (name) => {
    try {
      const cwd = process.cwd();
      console.log("\n🧹 Starting removal...\n");

      const itemRegistry = registry[name];

      if (!itemRegistry) {
        console.log(`❌ "${name}" not found in registry`);
        return;
      }

      const isTsProject = fs.existsSync(path.join(cwd, "tsconfig.json"));
      const itemName = name.includes("/") ? name.split("/")[1] : name;

      const componentDir = path.join(cwd, "src/components/pejay-ui");
      const utilsDir = path.join(cwd, "src/utils/pejay-ui");

      let removedAny = false;

      /* ---------------- REMOVE COMPONENT ---------------- */
      const exts = isTsProject ? ["tsx", "ts"] : ["jsx", "js"];

      for (const ext of exts) {
        const file = path.join(componentDir, `${itemName}.${ext}`);

        if (fs.existsSync(file)) {
          await fs.remove(file);
          console.log(`🗑️ Removed ${file}`);
          removedAny = true;
        }
      }

      /* ---------------- LOAD STATE ---------------- */
      const statePath = path.join(cwd, ".pejay-ui.json");

      let state = {};
      if (fs.existsSync(statePath)) {
        state = JSON.parse(await fs.readFile(statePath, "utf8"));
      }

      state.installed = state.installed || {};

      /* ---------------- BUILD USAGE MAP ---------------- */
      const usageMap = new Map();

      for (const comp of Object.values(state.installed)) {
        for (const u of comp.uses || []) {
          usageMap.set(u, (usageMap.get(u) || 0) + 1);
        }
      }

      /* ---------------- SAFE UTILITY REMOVE ---------------- */
      if (itemRegistry.dependencies?.length) {
        for (const dep of itemRegistry.dependencies) {
          const utilName = dep.includes("/") ? dep.split("/")[1] : dep;

          const usage = usageMap.get(utilName) || 0;

          if (usage > 1) {
            console.log(`⛔ Skipping ${utilName} (used by other components)`);
            continue;
          }

          const { confirm } = await prompt([
            {
              type: "confirm",
              name: "confirm",
              message: `Remove utility "${utilName}"?`,
              default: false,
            },
          ]);

          if (!confirm) continue;

          for (const ext of exts) {
            const file = path.join(utilsDir, `${utilName}.${ext}`);

            if (fs.existsSync(file)) {
              await fs.remove(file);
              console.log(`🗑️ Removed ${file}`);
              removedAny = true;
            }
          }
        }
      }

      /* ---------------- REMOVE PACKAGES ---------------- */
      // Only collect packages from deps that NO other component still uses
      const pkgs = [];

      for (const dep of itemRegistry.dependencies || []) {
        const utilName = dep.includes("/") ? dep.split("/")[1] : dep;
        const usage = usageMap.get(utilName) || 0;

        // usage > 1 means another component still needs this dep → skip its packages
        if (usage > 1) {
          console.log(`⛔ Keeping packages for ${utilName} (used by other components)`);
          continue;
        }

        const reg = registry[dep];
        if (reg?.packages) pkgs.push(...reg.packages);
      }

      if (pkgs.length) {
        const unique = [...new Set(pkgs)];

        const { ok } = await prompt([
          {
            type: "confirm",
            name: "ok",
            message: `Uninstall packages: ${unique.join(", ")}?`,
            default: false,
          },
        ]);

        if (ok) {
          execSync(`npm uninstall ${unique.join(" ")}`, {
            cwd,
            stdio: "inherit",
          });
        }
      }

      /* ---------------- CLEAN STATE ---------------- */
      if (state.installed[name]) {
        delete state.installed[name];
        await fs.writeFile(statePath, JSON.stringify(state, null, 2));
      }

      console.log(`\n🎉 ${name} removed successfully\n`);
    } catch (err) {
      console.error("\n❌ Remove failed\n", err);
    }
  });

program.parse();

{
  "name": "demo-dev2d-cli",
  "version": "1.0.0",
  "description": "CLI to install reusable React components like shadcn/ui",
  "main": "bin/index.js",
  "bin": {
    "demo-dev2d-cli": "./bin/index.js"
  },
  "files": [
    "bin",
    "templates",
    "utils",
    "registry.json"
  ],
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "demo-auth",
  "license": "ISC",
  "dependencies": {
    "@babel/core": "^7.29.0",
    "@babel/preset-react": "^7.28.5",
    "@babel/preset-typescript": "^7.28.5",
    "@types/react": "^19.2.14",
    "clsx": "^2.1.1",
    "commander": "^14.0.3",
    "fs-extra": "^11.3.5",
    "inquirer": "^13.4.3",
    "react": "^19.2.6",
    "tailwind-merge": "^3.6.0"
  }
}

{
  "input": {
    "dependencies": ["utils/cn"]
  },

  "utils/cn": {
    "packages": ["clsx", "tailwind-merge"]
  }
}

c

pjdev2d — Mon, 18 May 2026 06:34:10 +0000

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##devglan##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

Tasks

pjdev2d — Thu, 07 May 2026 13:50:39 +0000

responsive menu
date range picker
redux slice for data storage and hooks to call no states

=========================================

Remote Registry System
Fetch registry from API/CDN/GitHub
Dynamic component updates
No need to republish npm package for every component
Version-based registry management
Features
Remote registry.json
CDN support
GitHub raw file support
Cached registry
init Command
npx demo-dev2d-cli init
Responsibilities
Detect framework
Setup folders
Create .pejay-ui.json
Configure aliases
Install Tailwind
Create base config
Framework Detection
Vite
Next.js
CRA
Remix
Expo
Automatic Dependency Installation
Current
Registry tracks packages only
Upgrade

Automatically run:npm install clsx tailwind-merge
Features
Install missing packages
Skip already installed packages
Support npm/yarn/pnpm/bun

Recursive Dependency Resolution Current One-level dependency handling Upgrade

Support nested dependencies:
button
└── utils/cn
└── utils/theme

  Features

Recursive resolver
Circular dependency protection
Dependency graph generation

Component Variants & Themes npx demo-dev2d-cli add button --variant modern

Possible Styles
glass
modern
minimal
neumorphism
Features
Multiple template support
Theme presets
Style registry

doctor Command
npx demo-dev2d-cli doctor
Checks
Tailwind installed?
TypeScript configured?
React version compatible?
Aliases configured?
Missing packages?
Output
Errors
Warnings
Suggested fixes
list Command
npx demo-dev2d-cli list
Features
Show installed components
Show available components
Show outdated components
Show dependency usage
Update Command
npx demo-dev2d-cli update input
Features
Smart file diffing
Preserve user changes
Partial updates
Version updates
Framework Detection System
Detect Automatically
Next.js
Vite
CRA
Remix
Expo
Monorepo
Features
Framework-specific templates
Framework-specific paths
Framework-specific co
Remote Templates
templates/input.tsx
Upgrade

Fetch from:

GitHub
CDN
API
Benefits
Smaller npm package
Dynamic template updates
Centralized template management

Registry Validation
Use
Zod
AJV
Validate
Component schema
Dependency schema
Template structure
Benefits
Prevent broken installs
Safer updates
Better DX
AST-Based Code Manipulation
Features
Auto export injection
Auto import updates
Route injection
Provider injection
Tools
Babel AST
Recast
TS Morph
Interactive CLI UI
Features
Multi-select components
Searchable lists
Loading spinners
Colored logs
Tools
Inquirer
Ora
Chalk
Rollback & Recovery System
Features
Restore failed installs
Cleanup partial files
Transaction-based installs
Benefits
Safe operations
Better reliability
Component Marketplace
Future Scope
Public registry
Premium packs
Themes marketplace
Community components
SaaS Potential
Paid templates
Team registries
Private registries

===================================================================

Recommended Upgrade Order
Phase 1 (Most Important)
init command
Automatic dependency installation
Remote registry
Recursive dependency resolution
Phase 2
Framework detection
doctor command
list command
Remote templates
Phase 3
Update system
AST manipulation
Interactive UI
Rollback system
Phase 4 (Advanced)
Marketplace
SaaS ecosystem
Team/private registries