@vef-framework/dev 2.0.4 → 2.0.5

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

@@ -1,225 +1,161 @@
-/*! @vef-framework/dev v2.0.3 made with ❤️ by Venus | 2025-11-26T02:32:33.686Z */
-import { visit, types } from '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 = [
+import { visit as l, types as n } from "recast";
+const v = /[\u4E00-\u9FFF\u3400-\u4DBF\uFF00-\uFFEF]/, T = "operationColumn", I = "OperationButton", x = [
   "@vef-framework/components",
   "@vef-framework/starter"
 ];
-function isValidImportSource(source) {
-  return VALID_IMPORT_SOURCES.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+function C(r) {
+  return x.some((e) => r === e || r.startsWith(`${e}/`));
 }
-function collectOperationButtonAliases(ast) {
-  const aliasMap = /* @__PURE__ */ new Map();
-  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 (types.namedTypes.ImportSpecifier.check(specifier)) {
-          const { imported } = specifier;
-          const { local } = specifier;
-          if (types.namedTypes.Identifier.check(imported) && types.namedTypes.Identifier.check(local) && imported.name === OPERATION_BUTTON_COMPONENT) {
-            aliasMap.set(local.name, imported.name);
-          }
+function S(r) {
+  const e = /* @__PURE__ */ new Map();
+  return l(r, {
+    visitImportDeclaration(t) {
+      const i = t.node.source.value;
+      if (typeof i != "string" || !C(i))
+        return this.traverse(t), !1;
+      for (const s of t.node.specifiers || [])
+        if (n.namedTypes.ImportSpecifier.check(s)) {
+          const { imported: o } = s, { local: a } = s;
+          n.namedTypes.Identifier.check(o) && n.namedTypes.Identifier.check(a) && o.name === I && e.set(a.name, o.name);
         }
-      }
-      this.traverse(path);
-      return false;
+      return this.traverse(t), !1;
     }
-  });
-  return aliasMap;
+  }), e;
 }
-function calculateTextWidth(text) {
-  let width = 0;
-  for (const char of text) {
-    width += CJK_CHAR_REGEX.test(char) ? 14 : 8;
-  }
-  return width;
+function O(r) {
+  let e = 0;
+  for (const t of r)
+    e += v.test(t) ? 14 : 8;
+  return e;
 }
-function calculateOperationColumnWidth(buttons) {
-  if (buttons.length === 0) {
+function P(r) {
+  if (r.length === 0)
     return {
       calculatedWidth: 64,
       buttonCount: 0,
       analysis: "No buttons found, using minimum width"
     };
+  let e = 0;
+  const t = r.length;
+  for (const [o, a] of r.entries()) {
+    let c = 16;
+    a.hasIcon && (c += 16, a.textContent && (c += 8)), a.textContent && (c += O(a.textContent)), c = Math.max(c, a.hasIcon && !a.textContent ? 32 : 64), e += c, o < t - 1 && (e += 8);
   }
-  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`;
+  e += 16;
+  const i = Math.ceil(e / 8) * 8, s = `${t} buttons, calculated: ${e}px, final: ${i}px`;
   return {
-    calculatedWidth: finalWidth,
-    buttonCount,
-    analysis
+    calculatedWidth: i,
+    buttonCount: t,
+    analysis: s
   };
 }
-function extractButtonInfo(jsxElement, aliasMap) {
-  const { openingElement } = jsxElement;
-  if (!types.namedTypes.JSXIdentifier.check(openingElement.name)) {
+function g(r, e) {
+  const { openingElement: t } = r;
+  if (!n.namedTypes.JSXIdentifier.check(t.name))
     return null;
-  }
-  const componentName = openingElement.name.name;
-  if (!aliasMap.has(componentName)) {
+  const i = t.name.name;
+  if (!e.has(i))
     return null;
-  }
-  const buttonInfo = {
-    hasIcon: false,
+  const s = {
+    hasIcon: !1,
     textContent: ""
   };
-  for (const attr of openingElement.attributes || []) {
-    if (types.namedTypes.JSXAttribute.check(attr) && types.namedTypes.JSXIdentifier.check(attr.name) && attr.name.name === "icon") {
-      buttonInfo.hasIcon = true;
-    }
-  }
-  for (const child of jsxElement.children || []) {
-    if (types.namedTypes.JSXText.check(child)) {
-      buttonInfo.textContent += child.value.trim();
-    } else if (types.namedTypes.JSXExpressionContainer.check(child) && types.namedTypes.StringLiteral.check(child.expression)) {
-      buttonInfo.textContent += child.expression.value;
-    }
-  }
-  return buttonInfo;
+  for (const o of t.attributes || [])
+    n.namedTypes.JSXAttribute.check(o) && n.namedTypes.JSXIdentifier.check(o.name) && o.name.name === "icon" && (s.hasIcon = !0);
+  for (const o of r.children || [])
+    n.namedTypes.JSXText.check(o) ? s.textContent += o.value.trim() : n.namedTypes.JSXExpressionContainer.check(o) && n.namedTypes.StringLiteral.check(o.expression) && (s.textContent += o.expression.value);
+  return s;
 }
-function findOperationButtons(node, aliasMap) {
-  const buttons = [];
-  visit(node, {
-    visitJSXElement(path) {
-      const buttonInfo = extractButtonInfo(path.node, aliasMap);
-      if (buttonInfo) {
-        buttons.push(buttonInfo);
-      }
-      this.traverse(path);
-      return false;
+function k(r, e) {
+  const t = [];
+  return l(r, {
+    visitJSXElement(i) {
+      const s = g(i.node, e);
+      return s && t.push(s), this.traverse(i), !1;
     }
-  });
-  return buttons;
+  }), t;
 }
-function hasWidthProperty(objectExpression) {
-  return objectExpression.properties.some((prop) => {
-    if (types.namedTypes.ObjectProperty.check(prop)) {
-      const { key } = prop;
-      return types.namedTypes.Identifier.check(key) && key.name === "width" || types.namedTypes.StringLiteral.check(key) && key.value === "width";
+function E(r) {
+  return r.properties.some((e) => {
+    if (n.namedTypes.ObjectProperty.check(e)) {
+      const { key: t } = e;
+      return n.namedTypes.Identifier.check(t) && t.name === "width" || n.namedTypes.StringLiteral.check(t) && t.value === "width";
     }
-    return false;
+    return !1;
   });
 }
-function getRenderProperty(objectExpression) {
-  return objectExpression.properties.find((prop) => {
-    if (types.namedTypes.ObjectProperty.check(prop) || types.namedTypes.ObjectMethod.check(prop)) {
-      const { key } = prop;
-      return types.namedTypes.Identifier.check(key) && key.name === "render" || types.namedTypes.StringLiteral.check(key) && key.value === "render";
+function w(r) {
+  return r.properties.find((e) => {
+    if (n.namedTypes.ObjectProperty.check(e) || n.namedTypes.ObjectMethod.check(e)) {
+      const { key: t } = e;
+      return n.namedTypes.Identifier.check(t) && t.name === "render" || n.namedTypes.StringLiteral.check(t) && t.value === "render";
     }
-    return false;
+    return !1;
   });
 }
-function getComponentName(jsxElement) {
-  const { openingElement } = jsxElement;
-  if (types.namedTypes.JSXIdentifier.check(openingElement.name)) {
-    return openingElement.name.name;
-  }
-  if (types.namedTypes.JSXMemberExpression.check(openingElement.name)) {
-    const { object, property } = openingElement.name;
-    const objectName = types.namedTypes.JSXIdentifier.check(object) ? object.name : "?";
-    const propertyName = types.namedTypes.JSXIdentifier.check(property) ? property.name : "?";
-    return `${objectName}.${propertyName}`;
+function J(r) {
+  const { openingElement: e } = r;
+  if (n.namedTypes.JSXIdentifier.check(e.name))
+    return e.name.name;
+  if (n.namedTypes.JSXMemberExpression.check(e.name)) {
+    const { object: t, property: i } = e.name, s = n.namedTypes.JSXIdentifier.check(t) ? t.name : "?", o = n.namedTypes.JSXIdentifier.check(i) ? i.name : "?";
+    return `${s}.${o}`;
   }
   return "Unknown";
 }
-const operationColumnWidthPlugin = {
+const N = {
   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);
+  shouldProcess(r) {
+    return r.code.includes(T);
   },
-  transform(context) {
-    const aliasMap = collectOperationButtonAliases(context.ast);
-    if (aliasMap.size === 0) {
-      return { hasChanges: false, logs: [] };
-    }
-    let hasChanges = false;
-    const logs = [];
-    visit(context.ast, {
-      visitJSXAttribute(path) {
-        const attr = path.node;
-        if (!types.namedTypes.JSXIdentifier.check(attr.name) || attr.name.name !== OPERATION_COLUMN_ATTR) {
-          this.traverse(path);
-          return false;
-        }
-        if (!types.namedTypes.JSXExpressionContainer.check(attr.value) || !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 = 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 = types.builders.objectProperty(
-          types.builders.identifier("width"),
-          types.builders.numericLiteral(calculatedWidth)
+  transform(r) {
+    const e = S(r.ast);
+    if (e.size === 0)
+      return { hasChanges: !1, logs: [] };
+    let t = !1;
+    const i = [];
+    return l(r.ast, {
+      visitJSXAttribute(s) {
+        const o = s.node;
+        if (!n.namedTypes.JSXIdentifier.check(o.name) || o.name.name !== T)
+          return this.traverse(s), !1;
+        if (!n.namedTypes.JSXExpressionContainer.check(o.value) || !n.namedTypes.ObjectExpression.check(o.value.expression))
+          return this.traverse(s), !1;
+        const a = o.value.expression;
+        if (E(a))
+          return this.traverse(s), !1;
+        const c = w(a);
+        if (!c)
+          return this.traverse(s), !1;
+        const f = n.namedTypes.ObjectProperty.check(c) ? k(c.value, e) : k(c.body, e);
+        if (f.length === 0)
+          return this.traverse(s), !1;
+        const { calculatedWidth: m, analysis: d } = P(f), p = n.builders.objectProperty(
+          n.builders.identifier("width"),
+          n.builders.numericLiteral(m)
         );
-        widthProperty.comments = [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 (types.namedTypes.JSXElement.check(node)) {
-            componentName = getComponentName(node);
+        p.comments = [n.builders.commentLine(` Auto-calculated: ${d} `, !0, !1)], a.properties.unshift(p), t = !0;
+        let h = "Unknown", { parentPath: u } = s;
+        for (; u; ) {
+          const { node: y, parentPath: b } = u;
+          if (n.namedTypes.JSXElement.check(y)) {
+            h = J(y);
             break;
           }
-          parentPath = nextParentPath;
+          u = b;
         }
-        logs.push(
-          `📊 ${componentName}: ${context.fileName}`,
-          `   └─ 🎯 Operation column auto-width: ${calculatedWidth}px (${analysis})`
-        );
-        this.traverse(path);
-        return false;
+        return i.push(
+          `📊 ${h}: ${r.fileName}`,
+          `   └─ 🎯 Operation column auto-width: ${m}px (${d})`
+        ), this.traverse(s), !1;
       }
-    });
-    return {
-      hasChanges,
-      logs
+    }), {
+      hasChanges: t,
+      logs: i
     };
   }
 };
-
-export { operationColumnWidthPlugin };
+export {
+  N as operationColumnWidthPlugin
+};

package/dist/es/vite/plugin-conventional-config.js

@@ -1,39 +1,36 @@
-/*! @vef-framework/dev v2.0.3 made with ❤️ by Venus | 2025-11-26T02:32:33.686Z */
-import { createChunksConfig } from './chunks.js';
-import { DEFAULT_SERVER_PORT, ASSETS_DIR, VEF_FRAMEWORK_VERSION, DEFAULT_OUTPUT_DIR, ENV_BUILD_PREFIX, ENV_APP_PREFIX, ENV_DIR, PUBLIC_DIR } from './constants.js';
-import { defineConstants } from './define.js';
-import { createPostcssConfig } from './postcss.js';
-
-function createConventionalConfigPlugin({
-  appName,
-  appVersion,
-  basePublicPath,
-  projectDir,
-  outputDir,
-  serverPort,
-  proxies
+import { createChunksConfig as u } from "./chunks.js";
+import { DEFAULT_SERVER_PORT as p, ASSETS_DIR as e, VEF_FRAMEWORK_VERSION as m, DEFAULT_OUTPUT_DIR as c, ENV_BUILD_PREFIX as f, ENV_APP_PREFIX as v, ENV_DIR as h, PUBLIC_DIR as D } from "./constants.js";
+import { defineConstants as d } from "./define.js";
+import { createPostcssConfig as E } from "./postcss.js";
+function g({
+  appName: t,
+  appVersion: s,
+  basePublicPath: r,
+  projectDir: o,
+  outputDir: i,
+  serverPort: n,
+  proxies: a
 }) {
   return {
     name: "vef-framework:conventional-config",
-    config(_, { command }) {
-      const isDev = command === "serve";
+    config(_, { command: l }) {
       return {
         appType: "spa",
-        root: projectDir,
-        base: basePublicPath,
-        publicDir: PUBLIC_DIR,
-        envDir: ENV_DIR,
-        envPrefix: [ENV_BUILD_PREFIX, ENV_APP_PREFIX],
-        define: defineConstants(appName, appVersion, isDev),
+        root: o,
+        base: r,
+        publicDir: D,
+        envDir: h,
+        envPrefix: [f, v],
+        define: d(t, s, l === "serve"),
         css: {
           transformer: "postcss",
           modules: {
             scopeBehaviour: "local",
             localsConvention: "camelCaseOnly",
-            exportGlobals: true,
+            exportGlobals: !0,
             hashPrefix: "vef"
           },
-          postcss: createPostcssConfig(),
+          postcss: E(),
           preprocessorOptions: {
             scss: {}
           }
@@ -48,40 +45,41 @@ function createConventionalConfigPlugin({
           }
         },
         build: {
-          outDir: outputDir ?? DEFAULT_OUTPUT_DIR,
+          outDir: i ?? c,
           target: "es2024",
-          assetsDir: ASSETS_DIR,
+          assetsDir: e,
           assetsInlineLimit: 10240,
-          reportCompressedSize: false,
+          reportCompressedSize: !1,
           chunkSizeWarningLimit: 5120,
-          minify: true,
-          cssCodeSplit: true,
-          cssMinify: true,
-          sourcemap: false,
+          minify: !0,
+          cssCodeSplit: !0,
+          cssMinify: !0,
+          sourcemap: !1,
           rollupOptions: {
             input: {
               main: "index.html"
             },
             output: {
-              banner: `/*! Powered by VEF Framework v${VEF_FRAMEWORK_VERSION}.${appVersion ? ` App version v${appVersion}.` : ""} Built at ${(/* @__PURE__ */ new Date()).toISOString()} */`,
-              chunkFileNames: `${ASSETS_DIR}/js/[name]-[hash].js`,
-              entryFileNames: `${ASSETS_DIR}/js/[name]-[hash].js`,
-              assetFileNames: `${ASSETS_DIR}/[ext]/[name]-[hash].[ext]`,
-              manualChunks: createChunksConfig()
+              banner: `/*! Powered by VEF Framework v${m}.${s ? ` App version v${s}.` : ""} Built at ${(/* @__PURE__ */ new Date()).toISOString()} */`,
+              chunkFileNames: `${e}/js/[name]-[hash].js`,
+              entryFileNames: `${e}/js/[name]-[hash].js`,
+              assetFileNames: `${e}/[ext]/[name]-[hash].[ext]`,
+              manualChunks: u()
             }
           }
         },
         server: {
-          port: serverPort || DEFAULT_SERVER_PORT,
-          strictPort: true,
-          host: true,
-          allowedHosts: true,
-          open: true,
-          proxy: proxies
+          port: n || p,
+          strictPort: !0,
+          host: !0,
+          allowedHosts: !0,
+          open: !0,
+          proxy: a
         }
       };
     }
   };
 }
-
-export { createConventionalConfigPlugin };
+export {
+  g as createConventionalConfigPlugin
+};

package/dist/es/vite/plugin-eslint.js

@@ -1,20 +1,19 @@
-/*! @vef-framework/dev v2.0.3 made with ❤️ by Venus | 2025-11-26T02:32:33.686Z */
-import eslint from 'vite-plugin-eslint2';
-
-function createEslintPlugin() {
-  return eslint({
-    fix: false,
-    test: false,
-    dev: true,
-    build: false,
-    cache: true,
+import e from "vite-plugin-eslint2";
+function r() {
+  return e({
+    fix: !1,
+    test: !1,
+    dev: !0,
+    build: !1,
+    cache: !0,
     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
+    emitError: !0,
+    emitWarning: !0,
+    emitWarningAsError: !0
   });
 }
-
-export { createEslintPlugin };
+export {
+  r as createEslintPlugin
+};

package/dist/es/vite/plugin-html.js

@@ -1,8 +1,5 @@
-/*! @vef-framework/dev v2.0.3 made with ❤️ by Venus | 2025-11-26T02:32:33.686Z */
-import { minify } from 'html-minifier-terser';
-
-const virtualModuleId = "index.html";
-const htmlContent = `
+import { minify as o } from "html-minifier-terser";
+const i = "index.html", a = `
 <!doctype html>
 <html lang="en">
   <head>
@@ -146,67 +143,59 @@ const htmlContent = `
   </body>
 </html>
 `;
-function createHtmlPlugin() {
+function l() {
   return [
     {
       name: "vef-framework:html",
-      resolveId(source) {
-        if (source === virtualModuleId) {
-          return virtualModuleId;
-        }
-        return null;
+      resolveId(t) {
+        return t === i ? i : null;
       },
-      load(id) {
-        if (id === virtualModuleId) {
-          return htmlContent;
-        }
-        return null;
+      load(t) {
+        return t === i ? a : null;
       },
       transformIndexHtml: {
         order: "pre",
-        handler: () => htmlContent
+        handler: () => a
       }
     },
     {
       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 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
-              }
-            );
-          }
-        }
+      async generateBundle(t, n) {
+        for (const e of Object.values(n))
+          e.type === "asset" && typeof e.source == "string" && e.fileName === i && (e.source = await o(
+            e.source,
+            {
+              collapseBooleanAttributes: !0,
+              collapseInlineTagWhitespace: !0,
+              collapseWhitespace: !0,
+              conservativeCollapse: !1,
+              keepClosingSlash: !0,
+              minifyCSS: !0,
+              minifyJS: !0,
+              minifyURLs: !0,
+              noNewlinesBeforeTagClose: !0,
+              quoteCharacter: '"',
+              removeAttributeQuotes: !1,
+              removeComments: !0,
+              removeEmptyAttributes: !0,
+              removeOptionalTags: !1,
+              removeRedundantAttributes: !0,
+              removeScriptTypeAttributes: !1,
+              removeTagWhitespace: !1,
+              removeEmptyElements: !1,
+              removeStyleLinkTypeAttributes: !1,
+              sortAttributes: !0,
+              sortClassName: !0,
+              trimCustomFragments: !0,
+              useShortDoctype: !0,
+              html5: !0
+            }
+          ));
       }
     }
   ];
 }
-
-export { createHtmlPlugin };
+export {
+  l as createHtmlPlugin
+};

package/dist/es/vite/plugin-icons.js

@@ -1,17 +1,16 @@
-/*! @vef-framework/dev v2.0.3 made with ❤️ by Venus | 2025-11-26T02:32:33.686Z */
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import icons from 'unplugin-icons/vite';
-
-function createIconsPlugin(projectDir) {
-  return icons({
-    autoInstall: false,
+import { resolve as e, dirname as l } from "node:path";
+import { fileURLToPath as r } from "node:url";
+import t from "unplugin-icons/vite";
+function n(o) {
+  return t({
+    autoInstall: !1,
     compiler: "jsx",
     jsx: "react",
     defaultClass: "inline-block",
     scale: 1.2,
-    collectionsNodeResolvePath: [projectDir, resolve(dirname(fileURLToPath(import.meta.url)), "..")]
+    collectionsNodeResolvePath: [o, e(l(r(import.meta.url)), "..")]
   });
 }
-
-export { createIconsPlugin };
+export {
+  n as createIconsPlugin
+};