@harpy-js/core 0.4.7

package/dist/i18n/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18N_MODULE_OPTIONS = exports.tUnsafe = exports.t = exports.CurrentLocale = exports.I18nSwitcherController = exports.I18nHelper = exports.I18nInterceptor = exports.I18nService = exports.I18nModule = void 0;
+var i18n_module_1 = require("./i18n.module");
+Object.defineProperty(exports, "I18nModule", { enumerable: true, get: function () { return i18n_module_1.I18nModule; } });
+var i18n_service_1 = require("./i18n.service");
+Object.defineProperty(exports, "I18nService", { enumerable: true, get: function () { return i18n_service_1.I18nService; } });
+var i18n_interceptor_1 = require("./i18n.interceptor");
+Object.defineProperty(exports, "I18nInterceptor", { enumerable: true, get: function () { return i18n_interceptor_1.I18nInterceptor; } });
+var i18n_helper_1 = require("./i18n.helper");
+Object.defineProperty(exports, "I18nHelper", { enumerable: true, get: function () { return i18n_helper_1.I18nHelper; } });
+var i18n_switcher_controller_1 = require("./i18n-switcher.controller");
+Object.defineProperty(exports, "I18nSwitcherController", { enumerable: true, get: function () { return i18n_switcher_controller_1.I18nSwitcherController; } });
+var locale_decorator_1 = require("./locale.decorator");
+Object.defineProperty(exports, "CurrentLocale", { enumerable: true, get: function () { return locale_decorator_1.CurrentLocale; } });
+var t_1 = require("./t");
+Object.defineProperty(exports, "t", { enumerable: true, get: function () { return t_1.t; } });
+Object.defineProperty(exports, "tUnsafe", { enumerable: true, get: function () { return t_1.tUnsafe; } });
+var i18n_module_options_1 = require("./i18n-module.options");
+Object.defineProperty(exports, "I18N_MODULE_OPTIONS", { enumerable: true, get: function () { return i18n_module_options_1.I18N_MODULE_OPTIONS; } });

package/dist/i18n/locale.decorator.d.ts

@@ -0,0 +1 @@
+export declare const CurrentLocale: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/dist/i18n/locale.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentLocale = void 0;
+const common_1 = require("@nestjs/common");
+exports.CurrentLocale = (0, common_1.createParamDecorator)((data, ctx) => {
+    const request = ctx.switchToHttp().getRequest();
+    return request.locale;
+});

package/dist/i18n/t.d.ts

@@ -0,0 +1,3 @@
+import type { NestedKeyOf, DeepValue, ExtractVariables } from "./i18n-types";
+export declare function t<TDict extends Record<string, any>, TKey extends NestedKeyOf<TDict>>(dict: TDict, key: TKey, vars?: DeepValue<TDict, TKey> extends string ? ExtractVariables<DeepValue<TDict, TKey>> : Record<string, string | number>): string;
+export declare function tUnsafe(dict: Record<string, any>, key: string, vars?: Record<string, string | number>): string;

package/dist/i18n/t.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.t = t;
+exports.tUnsafe = tUnsafe;
+function t(dict, key, vars) {
+    const value = key.split(".").reduce((acc, k) => acc?.[k], dict);
+    if (typeof value !== "string")
+        return "";
+    return value.replace(/\{\{(.*?)\}\}/g, (_match, k) => String(vars?.[k.trim()] ?? ""));
+}
+function tUnsafe(dict, key, vars) {
+    const value = key.split(".").reduce((acc, k) => acc?.[k], dict);
+    if (typeof value !== "string")
+        return "";
+    return value.replace(/\{\{(.*?)\}\}/g, (_match, k) => String(vars?.[k.trim()] ?? ""));
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { autoWrapClientComponent } from "./core/client-component-wrapper";
+export { hydrationContext, initializeHydrationContext } from "./core/hydration";
+export { getChunkPath, getHydrationManifest } from "./core/hydration-manifest";
+export { withJsxEngine } from "./core/jsx.engine";
+export { LiveReloadController } from "./core/live-reload.controller";
+export { StaticAssetsController } from "./core/static-assets.controller";
+export { JsxRender } from "./decorators/jsx.decorator";
+export { WithLayout } from "./decorators/layout.decorator";
+export type { MetaOptions, RenderOptions } from "./decorators/jsx.decorator";
+export type { JsxLayout, JsxLayoutProps } from "./core/jsx.engine";
+export { RouterModule } from "./core/router.module";
+export { NavigationService } from "./core/navigation.service";
+export { AutoRegisterModule } from "./core/auto-register.module";
+export type { NavItem, NavSection } from "./core/types/nav.types";
+export type { NavigationRegistry } from "./core/types/nav.types";
+export { configureHarpyApp, HarpyAppOptions } from "./core/app-setup";
+export { setupHarpyApp } from "./core/app-setup";
+export { default as Link } from "./client/Link";
+export { buildHrefIndex, getActiveItemIdFromIndex, getActiveItemIdFromManifest, } from "./client/getActiveItemId";

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveItemIdFromManifest = exports.getActiveItemIdFromIndex = exports.buildHrefIndex = exports.Link = exports.setupHarpyApp = exports.configureHarpyApp = exports.AutoRegisterModule = exports.NavigationService = exports.RouterModule = exports.WithLayout = exports.JsxRender = exports.StaticAssetsController = exports.LiveReloadController = exports.withJsxEngine = exports.getHydrationManifest = exports.getChunkPath = exports.initializeHydrationContext = exports.hydrationContext = exports.autoWrapClientComponent = void 0;
+var client_component_wrapper_1 = require("./core/client-component-wrapper");
+Object.defineProperty(exports, "autoWrapClientComponent", { enumerable: true, get: function () { return client_component_wrapper_1.autoWrapClientComponent; } });
+var hydration_1 = require("./core/hydration");
+Object.defineProperty(exports, "hydrationContext", { enumerable: true, get: function () { return hydration_1.hydrationContext; } });
+Object.defineProperty(exports, "initializeHydrationContext", { enumerable: true, get: function () { return hydration_1.initializeHydrationContext; } });
+var hydration_manifest_1 = require("./core/hydration-manifest");
+Object.defineProperty(exports, "getChunkPath", { enumerable: true, get: function () { return hydration_manifest_1.getChunkPath; } });
+Object.defineProperty(exports, "getHydrationManifest", { enumerable: true, get: function () { return hydration_manifest_1.getHydrationManifest; } });
+var jsx_engine_1 = require("./core/jsx.engine");
+Object.defineProperty(exports, "withJsxEngine", { enumerable: true, get: function () { return jsx_engine_1.withJsxEngine; } });
+var live_reload_controller_1 = require("./core/live-reload.controller");
+Object.defineProperty(exports, "LiveReloadController", { enumerable: true, get: function () { return live_reload_controller_1.LiveReloadController; } });
+var static_assets_controller_1 = require("./core/static-assets.controller");
+Object.defineProperty(exports, "StaticAssetsController", { enumerable: true, get: function () { return static_assets_controller_1.StaticAssetsController; } });
+var jsx_decorator_1 = require("./decorators/jsx.decorator");
+Object.defineProperty(exports, "JsxRender", { enumerable: true, get: function () { return jsx_decorator_1.JsxRender; } });
+var layout_decorator_1 = require("./decorators/layout.decorator");
+Object.defineProperty(exports, "WithLayout", { enumerable: true, get: function () { return layout_decorator_1.WithLayout; } });
+var router_module_1 = require("./core/router.module");
+Object.defineProperty(exports, "RouterModule", { enumerable: true, get: function () { return router_module_1.RouterModule; } });
+var navigation_service_1 = require("./core/navigation.service");
+Object.defineProperty(exports, "NavigationService", { enumerable: true, get: function () { return navigation_service_1.NavigationService; } });
+var auto_register_module_1 = require("./core/auto-register.module");
+Object.defineProperty(exports, "AutoRegisterModule", { enumerable: true, get: function () { return auto_register_module_1.AutoRegisterModule; } });
+var app_setup_1 = require("./core/app-setup");
+Object.defineProperty(exports, "configureHarpyApp", { enumerable: true, get: function () { return app_setup_1.configureHarpyApp; } });
+var app_setup_2 = require("./core/app-setup");
+Object.defineProperty(exports, "setupHarpyApp", { enumerable: true, get: function () { return app_setup_2.setupHarpyApp; } });
+var Link_1 = require("./client/Link");
+Object.defineProperty(exports, "Link", { enumerable: true, get: function () { return __importDefault(Link_1).default; } });
+var getActiveItemId_1 = require("./client/getActiveItemId");
+Object.defineProperty(exports, "buildHrefIndex", { enumerable: true, get: function () { return getActiveItemId_1.buildHrefIndex; } });
+Object.defineProperty(exports, "getActiveItemIdFromIndex", { enumerable: true, get: function () { return getActiveItemId_1.getActiveItemIdFromIndex; } });
+Object.defineProperty(exports, "getActiveItemIdFromManifest", { enumerable: true, get: function () { return getActiveItemId_1.getActiveItemIdFromManifest; } });

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@harpy-js/core",
+  "version": "0.4.7",
+  "description": "Harpy - A powerful NestJS + React/JSX SSR framework with automatic hydration and i18n support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/use-i18n.d.ts",
+      "default": "./dist/client/use-i18n.js"
+    },
+    "./client/getActiveItemId": {
+      "types": "./dist/client/getActiveItemId.d.ts",
+      "default": "./dist/client/getActiveItemId.js"
+    },
+    "./client/Link": {
+      "types": "./dist/client/Link.d.ts",
+      "default": "./dist/client/Link.js"
+    }
+  },
+  "bin": {
+    "harpy": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc && cp src/core/live-reload-client.js dist/core/",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "nestjs",
+    "react",
+    "jsx",
+    "ssr",
+    "hydration"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/platform-fastify": "^11.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "dependencies": {
+    "@fastify/cookie": "^11.0.1",
+    "chokidar": "^3.6.0",
+    "esbuild": "^0.24.2",
+    "rxjs": "^7.8.1",
+    "tsx": "^4.20.6"
+  },
+  "devDependencies": {
+    "@nestjs/testing": "^11.0.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^22.19.1",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "fastify": "^5.6.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "d7a4f2ad108c68f2b441ad0c24385b45b1e046a3"
+}

package/scripts/analyze-styles.ts

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * Analyze page components to determine which styles are used
+ * This helps identify page-specific vs common styles
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+const SRC_DIR = path.join(__dirname, "../src");
+const FEATURES_DIR = path.join(SRC_DIR, "features");
+
+interface PageInfo {
+  name: string;
+  viewFiles: string[];
+  classes: Set<string>;
+}
+
+// Extract Tailwind classes from file content
+function extractClasses(content: string): Set<string> {
+  const classes = new Set<string>();
+  // Match className="..." and class="..."
+  const classMatches = content.match(/(?:className|class)="([^"]*)"/g) || [];
+
+  classMatches.forEach((match) => {
+    const classContent = match
+      .replace(/(?:className|class)="/, "")
+      .replace(/"$/, "");
+    const tokens = classContent.split(/\s+/);
+    tokens.forEach((token) => {
+      if (token.trim()) classes.add(token);
+    });
+  });
+
+  return classes;
+}
+
+// Find all pages and their view files
+function analyzePages(): PageInfo[] {
+  const pages: PageInfo[] = [];
+
+  if (!fs.existsSync(FEATURES_DIR)) return pages;
+
+  const featureDirs = fs
+    .readdirSync(FEATURES_DIR)
+    .filter((f) => fs.statSync(path.join(FEATURES_DIR, f)).isDirectory());
+
+  featureDirs.forEach((featureName) => {
+    const viewsDir = path.join(FEATURES_DIR, featureName, "views");
+    if (fs.existsSync(viewsDir)) {
+      const viewFiles = fs
+        .readdirSync(viewsDir)
+        .filter((f) => f.endsWith(".tsx") || f.endsWith(".ts"))
+        .map((f) => path.join(viewsDir, f));
+
+      const classes = new Set<string>();
+      viewFiles.forEach((file) => {
+        const content = fs.readFileSync(file, "utf-8");
+        const fileClasses = extractClasses(content);
+        fileClasses.forEach((c) => classes.add(c));
+      });
+
+      pages.push({
+        name: featureName,
+        viewFiles,
+        classes,
+      });
+    }
+  });
+
+  return pages;
+}
+
+// Also extract classes from layout
+function getLayoutClasses(): Set<string> {
+  const layoutFile = path.join(SRC_DIR, "core/views/layout.tsx");
+  if (fs.existsSync(layoutFile)) {
+    const content = fs.readFileSync(layoutFile, "utf-8");
+    return extractClasses(content);
+  }
+  return new Set();
+}
+
+function main() {
+  const pages = analyzePages();
+  const layoutClasses = getLayoutClasses();
+
+  console.log("📊 Page Style Analysis:\n");
+
+  pages.forEach((page) => {
+    console.log(`${page.name}: ${page.classes.size} classes`);
+    console.log(
+      `  Files: ${page.viewFiles.map((f) => path.basename(f)).join(", ")}`,
+    );
+  });
+
+  console.log(`\nlayout: ${layoutClasses.size} classes`);
+  console.log("\nCommon classes (used across multiple pages):");
+
+  const commonClasses = new Set<string>();
+  const classUsage = new Map<string, number>();
+
+  // Count usage across all pages and layout
+  layoutClasses.forEach((c) => classUsage.set(c, (classUsage.get(c) || 0) + 1));
+  pages.forEach((page) => {
+    page.classes.forEach((c) => {
+      classUsage.set(c, (classUsage.get(c) || 0) + 1);
+    });
+  });
+
+  classUsage.forEach((count, className) => {
+    if (count > 1) {
+      commonClasses.add(className);
+    }
+  });
+
+  console.log(`Total common: ${commonClasses.size}`);
+  console.log(
+    "Sample common classes:",
+    Array.from(commonClasses).slice(0, 10).join(", "),
+  );
+}
+
+main();

package/scripts/auto-wrap-exports.ts

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+/**
+ * Post-build script to automatically wrap client component exports
+ *
+ * This script:
+ * 1. Identifies components with 'use client' directive in source
+ * 2. Automatically wraps their compiled exports with autoWrapClientComponent
+ * 3. Allows developers to write components without manual wrapping
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+const PROJECT_ROOT = process.cwd();
+const SRC_DIR = path.join(PROJECT_ROOT, "src");
+const DIST_DIR = path.join(PROJECT_ROOT, "dist");
+
+interface ClientComponentInfo {
+  sourceFile: string;
+  compiledFile: string;
+  componentName: string;
+}
+
+/**
+ * Find all TypeScript/TSX files with 'use client' directive
+ */
+function findClientComponentsInSource(): Map<string, string> {
+  const clientComponents = new Map<string, string>(); // compiledFile -> componentName
+  const extensions = [".ts", ".tsx"];
+
+  function walkDir(dir: string) {
+    if (!fs.existsSync(dir)) return;
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          walkDir(fullPath);
+        }
+      } else if (extensions.includes(path.extname(entry.name))) {
+        try {
+          const content = fs.readFileSync(fullPath, "utf-8");
+
+          // Check for 'use client' directive at the start of the file
+          if (/^['"]use client['"]/.test(content.trim())) {
+            const fileName = path.basename(fullPath, path.extname(fullPath));
+            // Convert kebab-case to PascalCase
+            const componentName = fileName
+              .split("-")
+              .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+              .join("");
+
+            // Calculate the corresponding compiled file path
+            const relativePath = path.relative(SRC_DIR, fullPath);
+            const compiledPath = path.join(
+              DIST_DIR,
+              relativePath.replace(/\.tsx?$/, ".js"),
+            );
+
+            clientComponents.set(compiledPath, componentName);
+          }
+        } catch (error) {
+          console.error(`Error reading file ${fullPath}:`, error);
+        }
+      }
+    }
+  }
+
+  walkDir(SRC_DIR);
+  return clientComponents;
+}
+
+/**
+ * Transform a compiled JavaScript file to wrap the default export
+ * Handles SWC's Object.defineProperty pattern
+ */
+function transformCompiledFile(
+  filePath: string,
+  componentName: string,
+): boolean {
+  try {
+    if (!fs.existsSync(filePath)) {
+      console.warn(`⚠️  File not found: ${filePath}`);
+      return false;
+    }
+
+    let content = fs.readFileSync(filePath, "utf-8");
+
+    // Skip if already wrapped (contains autoWrapClientComponent)
+    if (content.includes("autoWrapClientComponent")) {
+      console.log(`  ✓ Already wrapped: ${path.basename(filePath)}`);
+      return true;
+    }
+
+    // Import the wrapper from @harpy-js/core package instead of relative path
+    const normalizedRelativePath = "@harpy-js/core";
+
+    // Add the require at the top of the file (after the 'use strict' and initial Object.defineProperty)
+    const requireStatement = `var { autoWrapClientComponent: _autoWrapClientComponent } = require("${normalizedRelativePath}");`;
+
+    // Ensure the require statement is added before any wrapping
+    if (
+      !content.includes(requireStatement) &&
+      !content.includes("_autoWrapClientComponent")
+    ) {
+      // Check if we have the 'use client' and Object.defineProperty pattern
+      if (
+        content.includes('"use strict"') &&
+        content.includes("Object.defineProperty")
+      ) {
+        // Find the last Object.defineProperty line before any exports
+        const lines = content.split("\n");
+        let insertIndex = -1;
+
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].includes("Object.defineProperty(exports")) {
+            insertIndex = i + 1;
+            break;
+          }
+        }
+
+        if (insertIndex !== -1) {
+          lines.splice(insertIndex, 0, requireStatement);
+          content = lines.join("\n");
+        }
+      } else {
+        // Fallback: insert at the beginning after any initial comments
+        const lines = content.split("\n");
+        let insertIndex = 0;
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].includes('"use strict"')) {
+            insertIndex = i + 1;
+            break;
+          }
+        }
+        lines.splice(insertIndex, 0, requireStatement);
+        content = lines.join("\n");
+      }
+    }
+
+    // SWC pattern: const _default = ComponentName;
+    const swcPattern = new RegExp(
+      `const\\s+_default\\s*=\\s*${componentName}\\s*;`,
+    );
+
+    if (swcPattern.test(content)) {
+      // Replace the _default assignment with a wrapped version
+      content = content.replace(
+        `const _default = ${componentName};`,
+        `const _default = _autoWrapClientComponent(${componentName}, '${componentName}');`,
+      );
+
+      fs.writeFileSync(filePath, content, "utf-8");
+      console.log(`  ✓ Wrapped: ${path.basename(filePath)}`);
+      return true;
+    }
+
+    // CommonJS pattern: exports.default = ComponentName;
+    const pattern1 = new RegExp(
+      `exports\\.default\\s*=\\s*${componentName}\\s*;`,
+    );
+    if (pattern1.test(content)) {
+      content = content.replace(
+        pattern1,
+        `var { autoWrapClientComponent } = require("${normalizedRelativePath}");\nexports.default = autoWrapClientComponent(${componentName}, '${componentName}');`,
+      );
+      fs.writeFileSync(filePath, content, "utf-8");
+      console.log(`  ✓ Wrapped: ${path.basename(filePath)}`);
+      return true;
+    }
+
+    // ES6 pattern: export default ComponentName;
+    const pattern2 = new RegExp(`export\\s+default\\s+${componentName}\\s*;`);
+    if (pattern2.test(content)) {
+      content = content.replace(
+        `export default ${componentName};`,
+        `import { autoWrapClientComponent as _autoWrapClientComponent } from "${normalizedRelativePath}";\nexport default _autoWrapClientComponent(${componentName}, '${componentName}');`,
+      );
+      fs.writeFileSync(filePath, content, "utf-8");
+      console.log(`  ✓ Wrapped: ${path.basename(filePath)}`);
+      return true;
+    }
+
+    // Named export pattern: exports.ComponentName = ComponentName;
+    const namedExportPattern = new RegExp(
+      `exports\\.${componentName}\\s*=\\s*${componentName}\\s*;`,
+    );
+    if (namedExportPattern.test(content)) {
+      content = content.replace(
+        namedExportPattern,
+        `exports.${componentName} = _autoWrapClientComponent(${componentName}, '${componentName}');`,
+      );
+      fs.writeFileSync(filePath, content, "utf-8");
+      console.log(`  ✓ Wrapped: ${path.basename(filePath)}`);
+      return true;
+    }
+
+    console.warn(
+      `  ⚠️  Could not find export pattern for ${componentName} in ${path.basename(filePath)}`,
+    );
+    return false;
+  } catch (error) {
+    console.error(`  ✗ Error transforming ${path.basename(filePath)}:`, error);
+    return false;
+  }
+}
+
+/**
+ * Main function
+ */
+function main(): void {
+  console.log("🔄 Auto-wrapping client component exports...\n");
+
+  const clientComponents = findClientComponentsInSource();
+
+  if (clientComponents.size === 0) {
+    console.log("⚠️  No client components found\n");
+    return;
+  }
+
+  console.log(`Found ${clientComponents.size} client component(s):\n`);
+
+  let wrapped = 0;
+  for (const [compiledPath, componentName] of clientComponents) {
+    if (transformCompiledFile(compiledPath, componentName)) {
+      wrapped++;
+    }
+  }
+
+  console.log(
+    `\n✨ Auto-wrap complete: ${wrapped}/${clientComponents.size} components wrapped\n`,
+  );
+}
+
+main();

package/scripts/build-css.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Build script for Tailwind CSS v4
+ * Compiles src/assets/styles.css to public/styles.css
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+const inputFile = path.join(__dirname, "../src/assets/styles.css");
+const outputFile = path.join(__dirname, "../public/styles.css");
+
+// Create public directory if it doesn't exist
+const publicDir = path.dirname(outputFile);
+if (!fs.existsSync(publicDir)) {
+  fs.mkdirSync(publicDir, { recursive: true });
+}
+
+// Read the input CSS file
+const inputCSS = fs.readFileSync(inputFile, "utf8");
+
+// Import and compile with Tailwind v4
+(async () => {
+  const tailwindModule = await import("@tailwindcss/postcss");
+  const compile =
+    (tailwindModule as any).default || (tailwindModule as any).compile;
+
+  try {
+    const output = await compile(inputCSS, {
+      file: inputFile,
+    });
+    fs.writeFileSync(outputFile, output.toString());
+    console.log("✅ CSS compiled successfully");
+  } catch (err) {
+    console.error("❌ CSS compilation failed:", err);
+    process.exit(1);
+  }
+})();