@vef-framework/dev 1.0.135 → 2.0.1

package/dist/cjs/vite/plugin-auto-enhance/plugins/operation-column-width.cjs

@@ -0,0 +1,229 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const recast = require('recast');
+
+const CJK_CHAR_REGEX = /[\u4E00-\u9FFF\u3400-\u4DBF\uFF00-\uFFEF]/;
+const OPERATION_COLUMN_ATTR = "operationColumn";
+const OPERATION_BUTTON_COMPONENT = "OperationButton";
+const VALID_IMPORT_SOURCES = [
+  "@vef-framework/components",
+  "@vef-framework/starter"
+];
+function isValidImportSource(source) {
+  return VALID_IMPORT_SOURCES.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+}
+function collectOperationButtonAliases(ast) {
+  const aliasMap = /* @__PURE__ */ new Map();
+  recast.visit(ast, {
+    visitImportDeclaration(path) {
+      const source = path.node.source.value;
+      if (typeof source !== "string" || !isValidImportSource(source)) {
+        this.traverse(path);
+        return false;
+      }
+      for (const specifier of path.node.specifiers || []) {
+        if (recast.types.namedTypes.ImportSpecifier.check(specifier)) {
+          const { imported } = specifier;
+          const { local } = specifier;
+          if (recast.types.namedTypes.Identifier.check(imported) && recast.types.namedTypes.Identifier.check(local) && imported.name === OPERATION_BUTTON_COMPONENT) {
+            aliasMap.set(local.name, imported.name);
+          }
+        }
+      }
+      this.traverse(path);
+      return false;
+    }
+  });
+  return aliasMap;
+}
+function calculateTextWidth(text) {
+  let width = 0;
+  for (const char of text) {
+    width += CJK_CHAR_REGEX.test(char) ? 14 : 8;
+  }
+  return width;
+}
+function calculateOperationColumnWidth(buttons) {
+  if (buttons.length === 0) {
+    return {
+      calculatedWidth: 64,
+      buttonCount: 0,
+      analysis: "No buttons found, using minimum width"
+    };
+  }
+  let totalWidth = 0;
+  const buttonCount = buttons.length;
+  for (const [index, button] of buttons.entries()) {
+    let buttonWidth = 16;
+    if (button.hasIcon) {
+      buttonWidth += 16;
+      if (button.textContent) {
+        buttonWidth += 8;
+      }
+    }
+    if (button.textContent) {
+      buttonWidth += calculateTextWidth(button.textContent);
+    }
+    buttonWidth = Math.max(buttonWidth, button.hasIcon && !button.textContent ? 32 : 64);
+    totalWidth += buttonWidth;
+    if (index < buttonCount - 1) {
+      totalWidth += 8;
+    }
+  }
+  totalWidth += 16;
+  const finalWidth = Math.ceil(totalWidth / 8) * 8;
+  const analysis = `${buttonCount} buttons, calculated: ${totalWidth}px, final: ${finalWidth}px`;
+  return {
+    calculatedWidth: finalWidth,
+    buttonCount,
+    analysis
+  };
+}
+function extractButtonInfo(jsxElement, aliasMap) {
+  const { openingElement } = jsxElement;
+  if (!recast.types.namedTypes.JSXIdentifier.check(openingElement.name)) {
+    return null;
+  }
+  const componentName = openingElement.name.name;
+  if (!aliasMap.has(componentName)) {
+    return null;
+  }
+  const buttonInfo = {
+    hasIcon: false,
+    textContent: ""
+  };
+  for (const attr of openingElement.attributes || []) {
+    if (recast.types.namedTypes.JSXAttribute.check(attr) && recast.types.namedTypes.JSXIdentifier.check(attr.name) && attr.name.name === "icon") {
+      buttonInfo.hasIcon = true;
+    }
+  }
+  for (const child of jsxElement.children || []) {
+    if (recast.types.namedTypes.JSXText.check(child)) {
+      buttonInfo.textContent += child.value.trim();
+    } else if (recast.types.namedTypes.JSXExpressionContainer.check(child) && recast.types.namedTypes.StringLiteral.check(child.expression)) {
+      buttonInfo.textContent += child.expression.value;
+    }
+  }
+  return buttonInfo;
+}
+function findOperationButtons(node, aliasMap) {
+  const buttons = [];
+  recast.visit(node, {
+    visitJSXElement(path) {
+      const buttonInfo = extractButtonInfo(path.node, aliasMap);
+      if (buttonInfo) {
+        buttons.push(buttonInfo);
+      }
+      this.traverse(path);
+      return false;
+    }
+  });
+  return buttons;
+}
+function hasWidthProperty(objectExpression) {
+  return objectExpression.properties.some((prop) => {
+    if (recast.types.namedTypes.ObjectProperty.check(prop)) {
+      const { key } = prop;
+      return recast.types.namedTypes.Identifier.check(key) && key.name === "width" || recast.types.namedTypes.StringLiteral.check(key) && key.value === "width";
+    }
+    return false;
+  });
+}
+function getRenderProperty(objectExpression) {
+  return objectExpression.properties.find((prop) => {
+    if (recast.types.namedTypes.ObjectProperty.check(prop) || recast.types.namedTypes.ObjectMethod.check(prop)) {
+      const { key } = prop;
+      return recast.types.namedTypes.Identifier.check(key) && key.name === "render" || recast.types.namedTypes.StringLiteral.check(key) && key.value === "render";
+    }
+    return false;
+  });
+}
+function getComponentName(jsxElement) {
+  const { openingElement } = jsxElement;
+  if (recast.types.namedTypes.JSXIdentifier.check(openingElement.name)) {
+    return openingElement.name.name;
+  }
+  if (recast.types.namedTypes.JSXMemberExpression.check(openingElement.name)) {
+    const { object, property } = openingElement.name;
+    const objectName = recast.types.namedTypes.JSXIdentifier.check(object) ? object.name : "?";
+    const propertyName = recast.types.namedTypes.JSXIdentifier.check(property) ? property.name : "?";
+    return `${objectName}.${propertyName}`;
+  }
+  return "Unknown";
+}
+const operationColumnWidthPlugin = {
+  name: "operation-column-width",
+  description: "Automatically calculate optimal width for operation columns based on button analysis",
+  shouldProcess(context) {
+    return context.code.includes(OPERATION_COLUMN_ATTR);
+  },
+  transform(context) {
+    const aliasMap = collectOperationButtonAliases(context.ast);
+    if (aliasMap.size === 0) {
+      return { hasChanges: false, logs: [] };
+    }
+    let hasChanges = false;
+    const logs = [];
+    recast.visit(context.ast, {
+      visitJSXAttribute(path) {
+        const attr = path.node;
+        if (!recast.types.namedTypes.JSXIdentifier.check(attr.name) || attr.name.name !== OPERATION_COLUMN_ATTR) {
+          this.traverse(path);
+          return false;
+        }
+        if (!recast.types.namedTypes.JSXExpressionContainer.check(attr.value) || !recast.types.namedTypes.ObjectExpression.check(attr.value.expression)) {
+          this.traverse(path);
+          return false;
+        }
+        const objectExpression = attr.value.expression;
+        if (hasWidthProperty(objectExpression)) {
+          this.traverse(path);
+          return false;
+        }
+        const renderProperty = getRenderProperty(objectExpression);
+        if (!renderProperty) {
+          this.traverse(path);
+          return false;
+        }
+        const buttons = recast.types.namedTypes.ObjectProperty.check(renderProperty) ? findOperationButtons(renderProperty.value, aliasMap) : findOperationButtons(renderProperty.body, aliasMap);
+        if (buttons.length === 0) {
+          this.traverse(path);
+          return false;
+        }
+        const { calculatedWidth, analysis } = calculateOperationColumnWidth(buttons);
+        const widthProperty = recast.types.builders.objectProperty(
+          recast.types.builders.identifier("width"),
+          recast.types.builders.numericLiteral(calculatedWidth)
+        );
+        widthProperty.comments = [recast.types.builders.commentLine(` Auto-calculated: ${analysis} `, true, false)];
+        objectExpression.properties.unshift(widthProperty);
+        hasChanges = true;
+        let componentName = "Unknown";
+        let { parentPath } = path;
+        while (parentPath) {
+          const { node, parentPath: nextParentPath } = parentPath;
+          if (recast.types.namedTypes.JSXElement.check(node)) {
+            componentName = getComponentName(node);
+            break;
+          }
+          parentPath = nextParentPath;
+        }
+        logs.push(
+          `📊 ${componentName}: ${context.fileName}`,
+          `   └─ 🎯 Operation column auto-width: ${calculatedWidth}px (${analysis})`
+        );
+        this.traverse(path);
+        return false;
+      }
+    });
+    return {
+      hasChanges,
+      logs
+    };
+  }
+};
+
+exports.operationColumnWidthPlugin = operationColumnWidthPlugin;

package/dist/cjs/vite/plugin-conventional-config.cjs

@@ -0,0 +1,91 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const chunks = require('./chunks.cjs');
+const constants = require('./constants.cjs');
+const define = require('./define.cjs');
+const postcss = require('./postcss.cjs');
+
+function createConventionalConfigPlugin({
+  appName,
+  appVersion,
+  basePublicPath,
+  projectDir,
+  outputDir,
+  serverPort,
+  proxies
+}) {
+  return {
+    name: "vef-framework:conventional-config",
+    config(_, { command }) {
+      const isDev = command === "serve";
+      return {
+        appType: "spa",
+        root: projectDir,
+        base: basePublicPath,
+        publicDir: constants.PUBLIC_DIR,
+        envDir: constants.ENV_DIR,
+        envPrefix: [constants.ENV_BUILD_PREFIX, constants.ENV_APP_PREFIX],
+        define: define.defineConstants(appName, appVersion, isDev),
+        css: {
+          transformer: "postcss",
+          modules: {
+            scopeBehaviour: "local",
+            localsConvention: "camelCaseOnly",
+            exportGlobals: true,
+            hashPrefix: "vef"
+          },
+          postcss: postcss.createPostcssConfig(),
+          preprocessorOptions: {
+            scss: {}
+          }
+        },
+        resolve: {
+          dedupe: ["react", "react-dom"]
+        },
+        optimizeDeps: {
+          exclude: [],
+          esbuildOptions: {
+            plugins: []
+          }
+        },
+        build: {
+          outDir: outputDir ?? constants.DEFAULT_OUTPUT_DIR,
+          target: "es2024",
+          assetsDir: constants.ASSETS_DIR,
+          assetsInlineLimit: 10240,
+          reportCompressedSize: false,
+          chunkSizeWarningLimit: 2560,
+          minify: true,
+          cssCodeSplit: true,
+          cssMinify: true,
+          sourcemap: false,
+          rollupOptions: {
+            input: {
+              main: "index.html"
+            },
+            output: {
+              banner: `/*! Powered by VEF Framework v${constants.VEF_FRAMEWORK_VERSION}.${appVersion ? ` App version v${appVersion}.` : ""} Built at ${(/* @__PURE__ */ new Date()).toISOString()} */`,
+              chunkFileNames: `${constants.ASSETS_DIR}/js/[name]-[hash].js`,
+              entryFileNames: `${constants.ASSETS_DIR}/js/[name]-[hash].js`,
+              assetFileNames: `${constants.ASSETS_DIR}/[ext]/[name]-[hash].[ext]`,
+              manualChunks: chunks.createChunksConfig()
+            }
+          }
+        },
+        server: {
+          port: serverPort || constants.DEFAULT_SERVER_PORT,
+          strictPort: true,
+          host: true,
+          allowedHosts: true,
+          open: true,
+          proxy: proxies
+        }
+      };
+    }
+  };
+}
+
+exports.createConventionalConfigPlugin = createConventionalConfigPlugin;

package/dist/cjs/vite/plugin-eslint.cjs

@@ -0,0 +1,24 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const eslint = require('vite-plugin-eslint2');
+
+function createEslintPlugin() {
+  return eslint({
+    fix: false,
+    test: false,
+    dev: true,
+    build: false,
+    cache: true,
+    cacheLocation: "node_modules/.cache/.eslintcache",
+    include: ["*.{js,ts,json,yaml,md}", "src/**/*.{ts,tsx,json,yaml,md}"],
+    exclude: ["node_modules", "virtual:", "vef:"],
+    emitError: true,
+    emitWarning: true,
+    emitWarningAsError: true
+  });
+}
+
+exports.createEslintPlugin = createEslintPlugin;

package/dist/cjs/vite/plugin-html.cjs

@@ -0,0 +1,216 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const htmlMinifierTerser = require('html-minifier-terser');
+
+const virtualModuleId = "index.html";
+const htmlContent = `
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="%VEF_APP_FAVICON%" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="Powered by VEF framework" />
+    <meta name="app-version" content="%VEF_APP_VERSION%" />
+    <meta name="app-changelog" content="%VEF_APP_CHANGELOG%" />
+    <title>%VEF_APP_TITLE%</title>
+  </head>
+  <body>
+    <noscript>
+      <h2>很抱歉，如果没有启用 JavaScript，%VEF_APP_NAME% 无法正常工作。请启用 JavaScript 再继续。</h2>
+    </noscript>
+    <div id="__vef-initialization-loader">
+      <style>
+        #__vef-initialization-loader {
+          position: fixed;
+          inset: 0;
+          z-index: 9999;
+          display: flex;
+          flex-direction: column;
+          justify-content: center;
+          row-gap: 16px;
+          align-items: center;
+          height: 100%;
+          background-color: #ffffff;
+        }
+
+        #__vef-initialization-loader .loader-box {
+          color: #000000;
+          font-size: 0;
+          width: 360px;
+          height: 160px;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          column-gap: 12px;
+        }
+
+        #__vef-initialization-loader .loader-box > span {
+          display: inline-block;
+          font-size: 48px;
+          font-weight: bold;
+          animation: text-wave 1.2s 0.4s linear infinite;
+        }
+
+        #__vef-initialization-loader .loader-box > span:nth-child(1) {
+          animation-delay: 0.1s;
+        }
+
+        #__vef-initialization-loader .loader-box > span:nth-child(2) {
+          animation-delay: 0.2s;
+        }
+
+        #__vef-initialization-loader .loader-box > span:nth-child(3) {
+          animation-delay: 0.3s;
+        }
+
+        #__vef-initialization-loader .loader-box > span:nth-child(4) {
+          animation-delay: 0.4s;
+        }
+
+        #__vef-initialization-loader .loader-box > span:nth-child(5) {
+          animation-delay: 0.5s;
+        }
+
+        #__vef-initialization-loader .loader-box > span:nth-child(6) {
+          animation-delay: 0.6s;
+        }
+
+        #__vef-initialization-loader .loader-title {
+          max-width: 80%;
+          font-size: 18px;
+          font-weight: normal;
+          line-height: 1.5;
+          color: #999999;
+        }
+
+        @keyframes text-wave {
+          0% {
+            transform: translateY(0);
+            opacity: 0.8;
+          }
+
+          25% {
+            transform: translateY(-16px);
+            opacity: 0.7;
+          }
+
+          50% {
+            transform: translateY(0);
+            opacity: 0.6;
+          }
+
+          75% {
+            transform: translateY(16px);
+            opacity: 0.7;
+          }
+
+          100% {
+            transform: translateY(0);
+            opacity: 0.8;
+          }
+        }
+      </style>
+      <div class="loader-box">
+        <span>资</span>
+        <span>源</span>
+        <span>加</span>
+        <span>载</span>
+        <span>中</span>
+        <span>...</span>
+      </div>
+      <div class="loader-title"></div>
+      <script>
+        (function() {
+          const text = "等待是一种修行，修行能让屏幕前的你参悟人生真谛，且珍惜这一段来之不易的等待吧！";
+          const element = document.querySelector(".loader-title");
+          let index = 0;
+          let currentText = "";
+
+          function typeWriter() {
+            if (index < text.length) {
+              currentText += text.charAt(index);
+              element.textContent = currentText;
+              index++;
+
+              const speed = Math.random() * 100 + 50;
+              setTimeout(typeWriter, speed);
+            }
+          }
+
+          setTimeout(typeWriter, 400);
+        })();
+      <\/script>
+    </div>
+    <div id="root"></div>
+    <script type="module" src="src/main.ts"><\/script>
+  </body>
+</html>
+`;
+function createHtmlPlugin() {
+  return [
+    {
+      name: "vef-framework:html",
+      resolveId(source) {
+        if (source === virtualModuleId) {
+          return virtualModuleId;
+        }
+        return null;
+      },
+      load(id) {
+        if (id === virtualModuleId) {
+          return htmlContent;
+        }
+        return null;
+      },
+      transformIndexHtml: {
+        order: "pre",
+        handler: () => htmlContent
+      }
+    },
+    {
+      name: "vef-framework:html-minify",
+      enforce: "post",
+      async generateBundle(_, bundles) {
+        for (const bundle of Object.values(bundles)) {
+          if (bundle.type === "asset" && typeof bundle.source === "string" && bundle.fileName === virtualModuleId) {
+            bundle.source = await htmlMinifierTerser.minify(
+              bundle.source,
+              {
+                collapseBooleanAttributes: true,
+                collapseInlineTagWhitespace: true,
+                collapseWhitespace: true,
+                conservativeCollapse: false,
+                keepClosingSlash: true,
+                minifyCSS: true,
+                minifyJS: true,
+                minifyURLs: true,
+                noNewlinesBeforeTagClose: true,
+                quoteCharacter: `"`,
+                removeAttributeQuotes: false,
+                removeComments: true,
+                removeEmptyAttributes: true,
+                removeOptionalTags: false,
+                removeRedundantAttributes: true,
+                removeScriptTypeAttributes: false,
+                removeTagWhitespace: false,
+                removeEmptyElements: false,
+                removeStyleLinkTypeAttributes: false,
+                sortAttributes: true,
+                sortClassName: true,
+                trimCustomFragments: true,
+                useShortDoctype: true,
+                html5: true
+              }
+            );
+          }
+        }
+      }
+    }
+  ];
+}
+
+exports.createHtmlPlugin = createHtmlPlugin;

package/dist/cjs/vite/plugin-icons.cjs

@@ -0,0 +1,22 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const node_path = require('node:path');
+const node_url = require('node:url');
+const icons = require('unplugin-icons/vite');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function createIconsPlugin(projectDir) {
+  return icons({
+    autoInstall: false,
+    compiler: "jsx",
+    jsx: "react",
+    defaultClass: "inline-block",
+    scale: 1.2,
+    collectionsNodeResolvePath: [projectDir, node_path.resolve(node_path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('vite/plugin-icons.cjs', document.baseURI).href)))), "..")]
+  });
+}
+
+exports.createIconsPlugin = createIconsPlugin;

package/dist/cjs/vite/plugin-injection.cjs

@@ -0,0 +1,20 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function createInjectionPlugin() {
+  return {
+    name: "vef-framework:injection"
+    //     transform(code, id) {
+    //       if (basename(dirname(id)) === "src" && basename(id).startsWith("main.ts")) {
+    //         return `import "@vef-react/components/styles.layer.css";
+    // import "@vef-react/starter/styles.layer.css";
+    // ${code}`;
+    //       }
+    //       return null;
+    //     }
+  };
+}
+
+exports.createInjectionPlugin = createInjectionPlugin;

package/dist/cjs/vite/plugin-inspect.cjs

@@ -0,0 +1,15 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const inspect = require('vite-plugin-inspect');
+
+function createInspectPlugin() {
+  return inspect({
+    dev: true,
+    build: false
+  });
+}
+
+exports.createInspectPlugin = createInspectPlugin;

package/dist/cjs/vite/plugin-react.cjs

@@ -0,0 +1,80 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const react = require('@vitejs/plugin-react');
+const chalk = require('chalk');
+
+function createReactPlugin({
+  useEmotion = false,
+  useCompiler = true,
+  babelPlugins
+} = {}) {
+  return react({
+    babel: {
+      plugins: [
+        ...useEmotion ? [
+          [
+            "@emotion",
+            {
+              sourceMap: true,
+              autoLabel: "never",
+              cssPropOptimization: true
+            }
+          ]
+        ] : [],
+        ...useCompiler ? [
+          [
+            "react-compiler",
+            {
+              /**
+               * `annotation`: Only compile functions that are explicitly marked with "use memo"
+               * `infer`: Use smart heuristics to identify React components and hooks
+               * Compilation conditions:
+               * Functions explicitly marked with "use memo"
+               * Functions named according to component or hook conventions (PascalCase or use prefix) that create JSX or call other hooks
+               */
+              compilationMode: "infer",
+              panicThreshold: "none",
+              target: "19",
+              logger: {
+                logEvent(filename, event) {
+                  switch (event.kind) {
+                    case "CompileSuccess": {
+                      break;
+                    }
+                    case "CompileError": {
+                      console.error(`${chalk.blueBright("[Compiler]")} ❌ ${chalk.redBright(`Skipped: ${filename}`)}`);
+                      console.error(chalk.red(`Reason: ${event.detail.reason}`));
+                      if (event.detail.description) {
+                        console.error(chalk.red(`Details: ${event.detail.description}`));
+                      }
+                      if (event.detail.loc) {
+                        const { line, column } = event.detail.loc.start;
+                        console.error(chalk.red(`Location: Line ${line}, Column ${column}`));
+                      }
+                      if (event.detail.suggestions) {
+                        console.error(chalk.yellow(`Suggestions: ${event.detail.suggestions.map((suggestion) => suggestion.description).join(" | ")}`));
+                      }
+                      break;
+                    }
+                    case "CompileSkip": {
+                      console.info(`${chalk.blueBright("[Compiler]")} ℹ️ ${chalk.gray(`Skipped: ${filename}`)}`, event);
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        ] : [],
+        "jotai/babel/plugin-debug-label",
+        "jotai/babel/plugin-react-refresh",
+        ...babelPlugins ?? []
+      ]
+    },
+    jsxImportSource: useEmotion ? "@emotion/react" : void 0
+  });
+}
+
+exports.createReactPlugin = createReactPlugin;