openxiangda 1.0.0

package/packages/sdk/src/build-source/scripts/utils/tailwind-config.mjs

@@ -0,0 +1,227 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const managedHeader = `const openxiangdaPath = require("node:path");
+const openxiangdaPresetModule = require("openxiangda/tailwind-preset");
+const openxiangdaPreset =
+  openxiangdaPresetModule.default ?? openxiangdaPresetModule;
+
+function resolveOpenXiangdaContent() {
+  try {
+    const packagePath = require.resolve("openxiangda");
+    const distDir = openxiangdaPath.dirname(packagePath);
+    return [openxiangdaPath.join(distDir, "..", "**/*.{js,mjs,cjs}")];
+  } catch {
+    return [];
+  }
+}
+
+const openxiangdaContent = resolveOpenXiangdaContent();
+`;
+const tailwindDirectives = ["base", "components", "utilities"];
+const requiredBlocklistEntries = ['"[-:T]"', '"[-:TZ.]"'];
+const layeredTailwindCss = `@import "openxiangda/styles/tokens.css";
+
+@layer tailwind-base {
+  @tailwind base;
+}
+
+@tailwind components;
+@tailwind utilities;
+`;
+
+export const canonicalTailwindConfig = `${managedHeader}
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+    ...openxiangdaContent,
+  ],
+  blocklist: ["[-:T]", "[-:TZ.]"],
+  presets: [openxiangdaPreset],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+};
+`;
+
+export function isWorkspaceTailwindConfigCurrent(content) {
+  return Boolean(
+    content.includes("openxiangda/tailwind-preset") &&
+    content.includes("resolveOpenXiangdaContent") &&
+    content.includes("openxiangdaContent") &&
+    content.includes("openxiangdaPreset") &&
+    content.includes("...openxiangdaContent") &&
+    hasBlocklistEntry(content, "[-:T]") &&
+    hasBlocklistEntry(content, "[-:TZ.]"),
+  );
+}
+
+export function isWorkspaceTailwindCssCurrent(content) {
+  return (
+    /@layer\s+tailwind-base\s*\{\s*@tailwind\s+base\s*;\s*\}/s.test(content) &&
+    !/@layer\s+tailwind-base\s*,\s*antd\s*;/.test(content) &&
+    tailwindDirectives
+      .filter((directive) => directive !== "base")
+      .every((directive) =>
+        new RegExp(`@tailwind\\s+${directive}\\s*;`).test(content),
+      )
+  );
+}
+
+function hasBlocklistEntry(content, entry) {
+  const singleQuoted = `'${entry.slice(1, -1)}'`;
+  return content.includes(entry) || content.includes(singleQuoted);
+}
+
+function insertAfterModuleExportsOpen(content, propertyLine) {
+  return content.replace(
+    /module\.exports\s*=\s*\{\s*/,
+    (match) => `${match}\n  ${propertyLine}\n`,
+  );
+}
+
+function ensureManagedHeader(content) {
+  if (content.includes("resolveOpenXiangdaContent")) return content;
+  return `${managedHeader}\n${content}`;
+}
+
+function ensureContentScan(content) {
+  if (content.includes("...openxiangdaContent")) {
+    return content;
+  }
+  if (/content\s*:\s*\[/.test(content)) {
+    return content.replace(
+      /content\s*:\s*\[/,
+      "content: [\n    ...openxiangdaContent,",
+    );
+  }
+  return insertAfterModuleExportsOpen(
+    content,
+    'content: ["./index.html", "./src/**/*.{js,ts,jsx,tsx}", ...openxiangdaContent],',
+  );
+}
+
+function ensurePreset(content) {
+  if (/presets\s*:\s*\[[^\]]*openxiangdaPreset/s.test(content)) {
+    return content;
+  }
+  if (/presets\s*:\s*\[/.test(content)) {
+    return content.replace(
+      /presets\s*:\s*\[/,
+      "presets: [openxiangdaPreset, ",
+    );
+  }
+  return insertAfterModuleExportsOpen(
+    content,
+    "presets: [openxiangdaPreset],",
+  );
+}
+
+function normalizeLegacyManagedNames(content) {
+  return content
+    .replace(
+      /const syLowcodePath = require\("node:path"\);[\s\S]*?const syLowcodeFormComponentsContent = resolveSyLowcodeFormComponentsContent\(\);\n*/g,
+      "",
+    )
+    .replace(/syLowcodeFormComponentsPreset/g, "openxiangdaPreset")
+    .replace(/syLowcodeFormComponentsContent/g, "openxiangdaContent")
+    .replace(/formComponentsPreset/g, "openxiangdaPreset")
+    .replace(/formComponentsContent/g, "openxiangdaContent");
+}
+
+function ensureBlocklist(content) {
+  if (!/blocklist\s*:\s*\[/.test(content)) {
+    return insertAfterModuleExportsOpen(
+      content,
+      'blocklist: ["[-:T]", "[-:TZ.]"],',
+    );
+  }
+
+  let nextContent = content;
+  for (const entry of [...requiredBlocklistEntries].reverse()) {
+    if (hasBlocklistEntry(nextContent, entry)) continue;
+    nextContent = nextContent.replace(
+      /blocklist\s*:\s*\[/,
+      `blocklist: [${entry}, `,
+    );
+  }
+  return nextContent;
+}
+
+export function patchWorkspaceTailwindConfig(content) {
+  if (!content.trim()) return canonicalTailwindConfig;
+  content = normalizeLegacyManagedNames(content);
+  if (isWorkspaceTailwindConfigCurrent(content)) return content;
+
+  let nextContent = ensureManagedHeader(content);
+  nextContent = ensureContentScan(nextContent);
+  nextContent = ensurePreset(nextContent);
+  nextContent = ensureBlocklist(nextContent);
+  return nextContent;
+}
+
+export function patchWorkspaceTailwindCss(content) {
+  if (isWorkspaceTailwindCssCurrent(content)) return content;
+
+  const customCss = content
+    .replace(/@import\s+["']openxiangda\/styles\/tokens\.css["'];\s*/g, "")
+    .replace(/@layer\s+tailwind-base\s*,\s*antd\s*;\s*/g, "")
+    .replace(/@layer\s+tailwind-base\s*\{\s*@tailwind\s+base\s*;\s*\}\s*/gs, "")
+    .replace(/@tailwind\s+(?:base|components|utilities)\s*;\s*/g, "")
+    .trimStart();
+
+  return customCss ? `${layeredTailwindCss}\n${customCss}` : layeredTailwindCss;
+}
+
+export function ensureWorkspaceTailwindConfig(workspaceRoot) {
+  const configPath = path.join(workspaceRoot, "tailwind.config.cjs");
+  const current = fs.existsSync(configPath)
+    ? fs.readFileSync(configPath, "utf-8")
+    : "";
+  const nextContent = patchWorkspaceTailwindConfig(current);
+  if (current !== nextContent) {
+    fs.writeFileSync(configPath, nextContent, "utf-8");
+  }
+
+  const cssPath = path.join(workspaceRoot, "src", "index.css");
+  const currentCss = fs.existsSync(cssPath)
+    ? fs.readFileSync(cssPath, "utf-8")
+    : "";
+  const nextCss = patchWorkspaceTailwindCss(currentCss);
+  if (currentCss !== nextCss) {
+    fs.mkdirSync(path.dirname(cssPath), { recursive: true });
+    fs.writeFileSync(cssPath, nextCss, "utf-8");
+  }
+
+  return {
+    changed: current !== nextContent || currentCss !== nextCss,
+    path: configPath,
+    cssPath,
+  };
+}
+
+export function validateWorkspaceTailwindConfig(workspaceRoot) {
+  const configPath = path.join(workspaceRoot, "tailwind.config.cjs");
+  if (!fs.existsSync(configPath)) {
+    return ["tailwind.config.cjs is missing"];
+  }
+  const content = fs.readFileSync(configPath, "utf-8");
+  if (!isWorkspaceTailwindConfigCurrent(content)) {
+    return [
+      "tailwind.config.cjs must include openxiangda/tailwind-preset and scan openxiangda package output",
+    ];
+  }
+  const cssPath = path.join(workspaceRoot, "src", "index.css");
+  const cssContent = fs.existsSync(cssPath)
+    ? fs.readFileSync(cssPath, "utf-8")
+    : "";
+  if (!isWorkspaceTailwindCssCurrent(cssContent)) {
+    return [
+      "src/index.css must keep Tailwind base in @layer tailwind-base and avoid declaring antd layer",
+    ];
+  }
+  return [];
+}

package/packages/sdk/src/build-source/scripts/utils/tailwind-config.test.ts

@@ -0,0 +1,187 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  ensureWorkspaceTailwindConfig,
+  patchWorkspaceTailwindCss,
+  patchWorkspaceTailwindConfig,
+  validateWorkspaceTailwindConfig,
+} from "./tailwind-config.mjs";
+
+let tempDirs: string[] = [];
+
+function createTempDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "workspace-tailwind-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  tempDirs = [];
+});
+
+describe("workspace Tailwind config helpers", () => {
+  it("patches stale app workspace config with openxiangda preset scanning", () => {
+    const workspaceRoot = createTempDir();
+    const configPath = path.join(workspaceRoot, "tailwind.config.cjs");
+    fs.writeFileSync(
+      configPath,
+      `module.exports = { content: ["./index.html", "./src/**/*.{js,ts,jsx,tsx}"], theme: { extend: {} }, plugins: [] };\n`,
+      "utf-8",
+    );
+
+    const result = ensureWorkspaceTailwindConfig(workspaceRoot);
+    const nextContent = fs.readFileSync(configPath, "utf-8");
+    const cssContent = fs.readFileSync(
+      path.join(workspaceRoot, "src", "index.css"),
+      "utf-8",
+    );
+
+    expect(result.changed).toBe(true);
+    expect(nextContent).toContain(
+      'require("openxiangda/tailwind-preset")',
+    );
+    expect(nextContent).toContain("...openxiangdaContent");
+    expect(cssContent).not.toContain("@layer tailwind-base, antd;");
+    expect(cssContent).toContain("@layer tailwind-base");
+    expect(cssContent).toContain("@tailwind base;");
+    expect(cssContent).toContain("@tailwind components;");
+    expect(cssContent).toContain("@tailwind utilities;");
+    expect(validateWorkspaceTailwindConfig(workspaceRoot)).toEqual([]);
+  });
+
+  it("preserves custom Tailwind config while adding runtime requirements", () => {
+    const source = `const customPlugin = require("./custom-plugin");
+
+module.exports = {
+  darkMode: "class",
+  content: ["./index.html", "./src/**/*.{js,ts,jsx,tsx}", "./features/**/*.{tsx,ts}"],
+  safelist: ["custom-safe-class"],
+  theme: {
+    extend: {
+      colors: {
+        brand: "#123456",
+      },
+    },
+  },
+  plugins: [customPlugin],
+};
+`;
+
+    const nextContent = patchWorkspaceTailwindConfig(source);
+
+    expect(nextContent).toContain("customPlugin");
+    expect(nextContent).toContain('"./features/**/*.{tsx,ts}"');
+    expect(nextContent).toContain('safelist: ["custom-safe-class"]');
+    expect(nextContent).toContain('brand: "#123456"');
+    expect(nextContent).toContain("plugins: [customPlugin]");
+    expect(nextContent).toContain(
+      'require("openxiangda/tailwind-preset")',
+    );
+    expect(nextContent).toContain("...openxiangdaContent");
+    expect(nextContent).toContain("presets: [openxiangdaPreset]");
+    expect(nextContent).toContain('"[-:T]"');
+    expect(nextContent).toContain('"[-:TZ.]"');
+  });
+
+  it("preserves existing index css while migrating to Tailwind base layer directives", () => {
+    const nextContent = patchWorkspaceTailwindCss(`@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+#root {
+  min-height: 100vh;
+}
+`);
+
+    expect(nextContent).not.toContain("@layer tailwind-base, antd;");
+    expect(nextContent).toContain("@layer tailwind-base");
+    expect(nextContent).toContain("@tailwind base;");
+    expect(nextContent).toContain("@tailwind components;");
+    expect(nextContent).toContain("@tailwind utilities;");
+    expect(nextContent).toContain("#root");
+    expect(nextContent.match(/@tailwind\s+base\s*;/g)).toHaveLength(1);
+  });
+
+  it("adds missing layered Tailwind directives without removing custom css", () => {
+    const nextContent = patchWorkspaceTailwindCss(`#root {
+  min-height: 100vh;
+}
+`);
+
+    expect(nextContent.startsWith("@layer tailwind-base {")).toBe(true);
+    expect(nextContent).toContain("@tailwind components;");
+    expect(nextContent).toContain("#root");
+  });
+
+  it("keeps current Tailwind base layer index css unchanged", () => {
+    const source = `@layer tailwind-base {
+  @tailwind base;
+}
+
+@tailwind components;
+@tailwind utilities;
+
+#root {
+  min-height: 100vh;
+}
+`;
+
+    expect(patchWorkspaceTailwindCss(source)).toBe(source);
+  });
+
+  it("removes stale antd layer declaration from index css", () => {
+    const nextContent = patchWorkspaceTailwindCss(`@layer tailwind-base, antd;
+
+@layer tailwind-base {
+  @tailwind base;
+}
+
+@tailwind components;
+@tailwind utilities;
+`);
+
+    expect(nextContent).not.toContain("@layer tailwind-base, antd;");
+    expect(nextContent.startsWith("@layer tailwind-base {")).toBe(true);
+  });
+
+  it("reports stale config during update check", () => {
+    const workspaceRoot = createTempDir();
+    fs.writeFileSync(
+      path.join(workspaceRoot, "tailwind.config.cjs"),
+      `module.exports = { content: ["./src/**/*.{ts,tsx}"] };\n`,
+      "utf-8",
+    );
+
+    expect(validateWorkspaceTailwindConfig(workspaceRoot)).toEqual([
+      "tailwind.config.cjs must include openxiangda/tailwind-preset and scan openxiangda package output",
+    ]);
+  });
+
+  it("reports missing Tailwind directives during update check", () => {
+    const workspaceRoot = createTempDir();
+    fs.mkdirSync(path.join(workspaceRoot, "src"), { recursive: true });
+    fs.writeFileSync(
+      path.join(workspaceRoot, "tailwind.config.cjs"),
+      patchWorkspaceTailwindConfig(
+        `module.exports = { content: ["./src/**/*.{ts,tsx}"] };\n`,
+      ),
+      "utf-8",
+    );
+    fs.writeFileSync(
+      path.join(workspaceRoot, "src", "index.css"),
+      "#root { min-height: 100vh; }\n",
+      "utf-8",
+    );
+
+    expect(validateWorkspaceTailwindConfig(workspaceRoot)).toEqual([
+      "src/index.css must keep Tailwind base in @layer tailwind-base and avoid declaring antd layer",
+    ]);
+  });
+});