@vef-framework/dev 1.0.134 → 2.0.1

package/dist/es/lint/index.js

@@ -0,0 +1,4 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+export { defineCommitlintConfig } from './commitlint.js';
+export { defineEslintConfig } from './eslint.js';
+export { defineStylelintConfig } from './stylelint.js';

package/dist/es/lint/stylelint.js

@@ -0,0 +1,88 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+import propertyGroups from 'stylelint-config-recess-order/groups';
+
+function defineStylelintConfig() {
+  return {
+    extends: [
+      "stylelint-config-standard-scss",
+      "stylelint-config-recommended"
+    ],
+    plugins: ["stylelint-order"],
+    rules: {
+      "order/order": [
+        "dollar-variables",
+        "at-variables",
+        "custom-properties",
+        "less-mixins",
+        "declarations",
+        "at-rules",
+        "rules"
+      ],
+      "order/properties-order": propertyGroups.map((group) => {
+        return {
+          ...group,
+          emptyLineBefore: "never",
+          noEmptyLineBetween: true
+        };
+      }),
+      "declaration-empty-line-before": "never",
+      "declaration-property-value-no-unknown": [
+        true,
+        {
+          ignoreProperties: {}
+        }
+      ],
+      "at-rule-no-unknown": [
+        true,
+        {
+          ignoreAtRules: ["extend", "include"]
+        }
+      ],
+      "function-no-unknown": [
+        true,
+        {
+          ignoreFunctions: []
+        }
+      ],
+      "number-max-precision": null,
+      "color-hex-length": "long",
+      "color-hex-alpha": "never",
+      "color-named": "never",
+      "unit-allowed-list": [
+        "px",
+        "em",
+        "rem",
+        "%",
+        "vw",
+        "vh",
+        "fr",
+        "deg",
+        "rad",
+        "grad",
+        "turn",
+        "ms",
+        "s"
+      ],
+      "selector-pseudo-class-no-unknown": [
+        true,
+        {
+          ignorePseudoClasses: ["global"]
+        }
+      ],
+      "scss/function-no-unknown": [
+        true,
+        {
+          ignoreFunctions: []
+        }
+      ],
+      "scss/at-rule-no-unknown": [
+        true,
+        {
+          ignoreAtRules: []
+        }
+      ]
+    }
+  };
+}
+
+export { defineStylelintConfig };

package/dist/es/vite/chunks.js

@@ -0,0 +1,26 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+function getChunk(id) {
+  if (id.includes("node_modules/@vef-framework/")) {
+    return "vef-framework";
+  }
+  if (id.includes("node_modules/lucide-react")) {
+    return "lucide-icons";
+  }
+  if (id.includes("node_modules/react/") || id.includes("node_modules/react-dom/") || id.includes("node_modules/scheduler/")) {
+    return "react";
+  }
+  if (id.includes("node_modules/@tanstack/")) {
+    return "tanstack";
+  }
+  if (id.includes("node_modules/pinyin-pro/") || id.includes("node_modules/@pinyin-pro/")) {
+    return "pinyin-vendor";
+  }
+  if (id.includes("node_modules/echarts/")) {
+    return "echarts";
+  }
+}
+function createChunksConfig() {
+  return getChunk;
+}
+
+export { createChunksConfig };

package/dist/es/vite/config.js

@@ -0,0 +1,79 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+import { resolve } from 'node:path';
+import process from 'node:process';
+import consola from 'consola';
+import fs from 'fs-extra';
+import { defineConfig, loadEnv } from 'vite';
+import { ENV_DIR, ENV_BUILD_PREFIX } from './constants.js';
+import { createAppConfigPlugin } from './plugin-app-config.js';
+import { createAutoEnhancePlugin } from './plugin-auto-enhance/index.js';
+import { createConventionalConfigPlugin } from './plugin-conventional-config.js';
+import { createEslintPlugin } from './plugin-eslint.js';
+import { createHtmlPlugin } from './plugin-html.js';
+import { createIconsPlugin } from './plugin-icons.js';
+import { createInjectionPlugin } from './plugin-injection.js';
+import { createInspectPlugin } from './plugin-inspect.js';
+import { createReactPlugin } from './plugin-react.js';
+import { createRouterPlugin } from './plugin-router.js';
+import { createStylelintPlugin } from './plugin-stylelint.js';
+import { createSvgrPlugin } from './plugin-svgr.js';
+import { createTsconfigPathsPlugin } from './plugin-tsconfig-paths.js';
+import { operationColumnWidthPlugin } from './plugin-auto-enhance/plugins/operation-column-width.js';
+
+function defineViteConfig({
+  resolve: resolve2,
+  plugins = [],
+  autoEnhancePlugins = [],
+  routerHistory = "browser",
+  react,
+  proxies
+} = {}) {
+  const projectDir = process.cwd();
+  return defineConfig(async ({ mode }) => {
+    const env = loadEnv(mode, ENV_DIR, ENV_BUILD_PREFIX);
+    if (Object.keys(env).length > 0) {
+      consola.info("Loaded environment variables:");
+      console.table(env);
+    }
+    const appVersion = await getAppVersion(projectDir);
+    return {
+      resolve: resolve2,
+      plugins: [
+        ...plugins,
+        createInspectPlugin(),
+        createConventionalConfigPlugin({
+          appName: env.VEF_APP_NAME,
+          appVersion,
+          projectDir,
+          basePublicPath: env.VEF_BUILD_BASE_PUBLIC_PATH,
+          outputDir: env.VEF_BUILD_OUTPUT_DIR,
+          serverPort: Number(env.VEF_BUILD_SERVER_PORT),
+          proxies
+        }),
+        createAutoEnhancePlugin({
+          plugins: [operationColumnWidthPlugin, ...autoEnhancePlugins]
+        }),
+        createRouterPlugin(projectDir, routerHistory),
+        createReactPlugin(react),
+        createTsconfigPathsPlugin(projectDir),
+        createHtmlPlugin(),
+        createInjectionPlugin(),
+        createAppConfigPlugin({
+          basePublicPath: env.VEF_BUILD_BASE_PUBLIC_PATH,
+          outputDir: env.VEF_BUILD_OUTPUT_DIR,
+          appName: env.VEF_APP_NAME
+        }),
+        createIconsPlugin(projectDir),
+        createSvgrPlugin(),
+        createEslintPlugin(),
+        createStylelintPlugin()
+      ].filter(Boolean)
+    };
+  });
+}
+async function getAppVersion(projectDir) {
+  const packageJson = await fs.readJson(resolve(projectDir, "package.json"), { encoding: "utf-8" });
+  return packageJson.version;
+}
+
+export { defineViteConfig };

package/dist/es/vite/constants.js

@@ -0,0 +1,15 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+const VEF_FRAMEWORK_VERSION = "1.0.0";
+const PUBLIC_DIR = "public";
+const ENV_DIR = "env";
+const ASSETS_DIR = "assets";
+const ENV_APP_PREFIX = "VEF_APP_";
+const ENV_BUILD_PREFIX = "VEF_BUILD_";
+const SRC_DIR = "src";
+const DEFAULT_OUTPUT_DIR = "dist";
+const DEFAULT_SERVER_PORT = 3833;
+const DEFAULT_APP_NAME = "APP";
+const PAGES_DIR = "pages";
+const ROUTER_DIR = "router";
+
+export { ASSETS_DIR, DEFAULT_APP_NAME, DEFAULT_OUTPUT_DIR, DEFAULT_SERVER_PORT, ENV_APP_PREFIX, ENV_BUILD_PREFIX, ENV_DIR, PAGES_DIR, PUBLIC_DIR, ROUTER_DIR, SRC_DIR, VEF_FRAMEWORK_VERSION };

package/dist/es/vite/define.js

@@ -0,0 +1,22 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+import { DEFAULT_APP_NAME, VEF_FRAMEWORK_VERSION, ENV_APP_PREFIX } from './constants.js';
+
+function defineConstants(appName, appVersion, isDev) {
+  return {
+    __VEF_FRAMEWORK_VERSION__: `"${VEF_FRAMEWORK_VERSION}"`,
+    __VEF_APP_VERSION__: `"${appVersion}"`,
+    __VEF_APP_CONFIG__: isDev ? `
+        (function () {
+          const env = import.meta.env;
+          const config = Object.keys(env).filter(key => key.startsWith(${JSON.stringify(ENV_APP_PREFIX)}))
+            .reduce((acc, key) => {
+              acc[key] = env[key];
+              return acc;
+            }, {});
+          return Object.freeze(config);
+        })()
+      ` : `window.__PRODUCTION__VEF_${appName ?? DEFAULT_APP_NAME}__CONF__`
+  };
+}
+
+export { defineConstants };

package/dist/es/vite/index.js

@@ -0,0 +1,3 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+export { defineViteConfig } from './config.js';
+import './plugin-auto-enhance/index.js';

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

@@ -0,0 +1,34 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+import { snake } from 'radashi';
+import config from 'unplugin-config/vite';
+import { ENV_APP_PREFIX, DEFAULT_OUTPUT_DIR, DEFAULT_APP_NAME } from './constants.js';
+
+function createAppConfigPlugin({
+  basePublicPath,
+  outputDir,
+  appName = DEFAULT_APP_NAME
+}) {
+  return config({
+    appName: `VEF_${constantCase(appName)}`,
+    baseDir: basePublicPath,
+    configFile: {
+      generate: true,
+      fileName: "app.config.js",
+      outputDir: outputDir ?? DEFAULT_OUTPUT_DIR
+    },
+    htmlInjection: {
+      enable: true,
+      position: "head-prepend",
+      templates: ["index.html"]
+    },
+    envVariables: {
+      prefix: ENV_APP_PREFIX,
+      files: ["env/.env", "env/.env.production"]
+    }
+  });
+}
+function constantCase(value) {
+  return snake(value).toUpperCase();
+}
+
+export { createAppConfigPlugin };

package/dist/es/vite/plugin-auto-enhance/core.js

@@ -0,0 +1,143 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+import { basename } from 'node:path';
+import { parse as parse$1 } from '@babel/parser';
+import { parse, print } from 'recast';
+
+function matchesPattern(patterns, target) {
+  const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+  return patternArray.some((pattern) => {
+    if (typeof pattern === "string") {
+      return target.includes(pattern);
+    }
+    return pattern.test(target);
+  });
+}
+class AutoEnhanceCore {
+  plugins = [];
+  options;
+  constructor(options = {}) {
+    this.options = {
+      include: [/\.tsx?(?:\?.*)?$/],
+      exclude: [/node_modules/, /\.d\.ts?(?:\?.*)?$/],
+      logPrefix: "🚀 VEF Auto-Enhance",
+      ...options
+    };
+  }
+  /**
+   * Register a sub-plugin
+   */
+  registerPlugin(plugin) {
+    this.plugins.push(plugin);
+  }
+  /**
+   * Register multiple sub-plugins
+   */
+  registerPlugins(plugins) {
+    for (const plugin of plugins) {
+      this.registerPlugin(plugin);
+    }
+  }
+  /**
+   * Check if file should be processed
+   */
+  shouldProcessFile(id) {
+    const { include, exclude } = this.options;
+    if (exclude && matchesPattern(exclude, id)) {
+      return false;
+    }
+    if (include && !matchesPattern(include, id)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Create processing context
+   */
+  createTransformationContext(id, code) {
+    const fileName = id.split("/").slice(-3).join("/");
+    const ast = parse(code, {
+      sourceFileName: basename(id),
+      parser: {
+        parse: (code2) => parse$1(code2, {
+          plugins: ["jsx", "typescript", "explicitResourceManagement"],
+          sourceType: "module",
+          tokens: true
+        })
+      }
+    });
+    return {
+      id,
+      fileName,
+      code,
+      ast
+    };
+  }
+  /**
+   * Execute transformation
+   */
+  transform(code, id) {
+    if (!this.shouldProcessFile(id)) {
+      return null;
+    }
+    if (this.plugins.length === 0) {
+      return null;
+    }
+    try {
+      const context = this.createTransformationContext(id, code);
+      const activePlugins = this.plugins.filter((plugin) => {
+        if (plugin.shouldProcess) {
+          return plugin.shouldProcess(context);
+        }
+        return true;
+      });
+      if (activePlugins.length === 0) {
+        return null;
+      }
+      let hasAnyChanges = false;
+      const allLogs = [];
+      for (const plugin of activePlugins) {
+        try {
+          const result = plugin.transform(context);
+          if (result.hasChanges) {
+            hasAnyChanges = true;
+          }
+          if (result.logs) {
+            allLogs.push(...result.logs);
+          }
+          if (result.hasChanges) {
+            console.log(`${this.options.logPrefix}: Plugin "${plugin.name}" made changes to ${context.fileName}`);
+          }
+        } catch (error) {
+          console.warn(`${this.options.logPrefix}: Plugin "${plugin.name}" failed:`, error);
+        }
+      }
+      for (const log of allLogs) {
+        console.log(log);
+      }
+      if (hasAnyChanges) {
+        const result = print(context.ast);
+        return {
+          code: result.code,
+          map: result.map || null
+        };
+      }
+      return null;
+    } catch (error) {
+      console.warn(`${this.options.logPrefix}: Error processing ${id}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Get registered plugin information
+   */
+  getRegisteredPlugins() {
+    return this.plugins.map((plugin) => {
+      return {
+        name: plugin.name,
+        description: plugin.description
+      };
+    });
+  }
+}
+
+export { AutoEnhanceCore };

package/dist/es/vite/plugin-auto-enhance/index.js

@@ -0,0 +1,32 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+import { AutoEnhanceCore } from './core.js';
+import './plugins/index.js';
+export { types } from 'recast';
+
+function createAutoEnhancePlugin({
+  plugins,
+  ...options
+} = {}) {
+  const core = new AutoEnhanceCore(options);
+  if (plugins) {
+    core.registerPlugins(plugins);
+  }
+  return {
+    name: "vef-framework:auto-enhance",
+    enforce: "pre",
+    buildStart() {
+      const plugins2 = core.getRegisteredPlugins();
+      if (plugins2.length > 0) {
+        console.log(`🚀 Auto-Enhance: Loaded ${plugins2.length} plugins:`);
+        for (const plugin of plugins2) {
+          console.log(`   • ${plugin.name}${plugin.description ? ` - ${plugin.description}` : ""}`);
+        }
+      }
+    },
+    transform(code, id) {
+      return core.transform(code, id);
+    }
+  };
+}
+
+export { createAutoEnhancePlugin };

package/dist/es/vite/plugin-auto-enhance/plugins/index.js

@@ -0,0 +1,2 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+export { operationColumnWidthPlugin } from './operation-column-width.js';

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

@@ -0,0 +1,225 @@
+/*! @vef-framework/dev v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.561Z */
+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 = [
+  "@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();
+  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);
+          }
+        }
+      }
+      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 (!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 (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;
+}
+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;
+    }
+  });
+  return buttons;
+}
+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";
+    }
+    return false;
+  });
+}
+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";
+    }
+    return false;
+  });
+}
+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}`;
+  }
+  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 = [];
+    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)
+        );
+        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);
+            break;
+          }
+          parentPath = nextParentPath;
+        }
+        logs.push(
+          `📊 ${componentName}: ${context.fileName}`,
+          `   └─ 🎯 Operation column auto-width: ${calculatedWidth}px (${analysis})`
+        );
+        this.traverse(path);
+        return false;
+      }
+    });
+    return {
+      hasChanges,
+      logs
+    };
+  }
+};
+
+export { operationColumnWidthPlugin };