@pit-frontend-framework/unplugin-vue-components 1.0.0

package/dist/types-BbnOeCab.d.mts

@@ -0,0 +1,217 @@
+import { TransformResult } from "unplugin";
+import { FilterPattern } from "unplugin-utils";
+
+//#region node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.d.mts
+/**
+ * Promise, or maybe not
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+/**
+ * Null or whatever
+ */
+//#endregion
+//#region src/types.d.ts
+interface ImportInfoLegacy {
+  /**
+   * @deprecated renamed to `as`
+   */
+  name?: string;
+  /**
+   * @deprecated renamed to `name`
+   */
+  importName?: string;
+  /**
+   * @deprecated renamed to `from`
+   */
+  path: string;
+  sideEffects?: SideEffectsInfo;
+}
+interface ImportInfo {
+  as?: string;
+  name?: string;
+  from: string;
+}
+type SideEffectsInfo = (ImportInfo | string)[] | ImportInfo | string | undefined;
+interface ComponentInfo extends ImportInfo {
+  sideEffects?: SideEffectsInfo;
+}
+type ComponentResolveResult = Awaitable<string | ComponentInfo | null | undefined | void>;
+type ComponentResolverFunction = (name: string) => ComponentResolveResult;
+interface ComponentResolverObject {
+  type: 'component' | 'directive';
+  resolve: ComponentResolverFunction;
+}
+type ComponentResolver = ComponentResolverFunction | ComponentResolverObject;
+type Matcher = (id: string) => boolean | null | undefined;
+type Transformer = (code: string, id: string, path: string, query: Record<string, string>) => Awaitable<TransformResult | null>;
+interface PublicPluginAPI {
+  /**
+   * Resolves a component using the configured resolvers.
+   */
+  findComponent: (name: string, filename?: string) => Promise<ComponentInfo | undefined>;
+  /**
+   * Obtain an import statement for a resolved component.
+   */
+  stringifyImport: (info: ComponentInfo) => string;
+}
+/**
+ * Plugin options.
+ */
+interface Options {
+  /**
+   * RegExp or glob to match files to be transformed
+   */
+  include?: FilterPattern;
+  /**
+   * RegExp or glob to match files to NOT be transformed
+   */
+  exclude?: FilterPattern;
+  /**
+   * RegExp or string to match component names that will NOT be imported
+   */
+  excludeNames?: FilterPattern;
+  /**
+   * Relative paths to the directory to search for components.
+   * @default 'src/components'
+   */
+  dirs?: string | string[];
+  /**
+   * Valid file extensions for components.
+   * @default ['vue']
+   */
+  extensions?: string | string[];
+  /**
+   * Glob patterns to match file names to be detected as components.
+   *
+   * When specified, the `dirs`, `extensions`, and `directoryAsNamespace` options will be ignored.
+   */
+  globs?: string | string[];
+  /**
+   * Negated glob patterns to exclude files from being detected as components.
+   *
+   * @default []
+   */
+  globsExclude?: string | string[];
+  /**
+   * Search for subdirectories
+   * @default true
+   */
+  deep?: boolean;
+  /**
+   * Allow subdirectories as namespace prefix for components
+   * @default false
+   */
+  directoryAsNamespace?: boolean;
+  /**
+   * Generate components with prefix.
+   */
+  prefix?: string;
+  /**
+   * Collapse same prefixes (camel-sensitive) of folders and components
+   * to prevent duplication inside namespaced component name.
+   *
+   * Works when `directoryAsNamespace: true`
+   * @default false
+   */
+  collapseSamePrefixes?: boolean;
+  /**
+   * Subdirectory paths for ignoring namespace prefixes
+   *
+   * Works when `directoryAsNamespace: true`
+   * @default "[]"
+   */
+  globalNamespaces?: string[];
+  /**
+   * Pass a custom function to resolve the component importing path from the component name.
+   *
+   * The component names are always in PascalCase
+   */
+  resolvers?: (ComponentResolver | ComponentResolver[])[];
+  /**
+   * Apply custom transform over the path for importing
+   */
+  importPathTransform?: (path: string) => string | undefined;
+  /**
+   * Tranform users' usage of resolveComponent/resolveDirective as well
+   *
+   * If disabled, only components inside templates (which compiles to `_resolveComponent` etc.)
+   * will be transformed.
+   *
+   * @default true
+   */
+  transformerUserResolveFunctions?: boolean;
+  /**
+   * Generate TypeScript declaration for global components
+   *
+   * Accept boolean or a path related to project root
+   *
+   * @see https://github.com/vuejs/core/pull/3399
+   * @see https://github.com/johnsoncodehk/volar#using
+   * @default true
+   */
+  dts?: boolean | string;
+  /**
+   * Generate TypeScript declaration for global components
+   * For TSX support
+   *
+   * @default true if `@vitejs/plugin-vue-jsx` is installed
+   */
+  dtsTsx?: boolean;
+  /**
+   * Do not emit warning on component overriding
+   *
+   * @default false
+   */
+  allowOverrides?: boolean;
+  /**
+   * auto import for directives.
+   * @default true
+   */
+  directives?: boolean;
+  /**
+   * Only provide types of components in library (registered globally)
+   */
+  types?: TypeImport[];
+  /**
+   * Generate sourcemap for the transformed code.
+   *
+   * @default true
+   */
+  sourcemap?: boolean;
+  /**
+   * Save component information into a JSON file for other tools to consume.
+   * Provide a filepath to save the JSON file.
+   *
+   * When set to `true`, it will save to `./.components-info.json`
+   *
+   * @default false
+   */
+  dumpComponentsInfo?: boolean | string;
+  /**
+   * The mode for syncing the components.d.ts and .components-info.json file.
+   * - `append`: only append the new components to the existing files.
+   * - `overwrite`: overwrite the whole existing files with the current components.
+   * - `default`: use `append` strategy when using dev server, `overwrite` strategy when using build.
+   *
+   * @default 'default'
+   */
+  syncMode?: 'default' | 'append' | 'overwrite';
+}
+type ResolvedOptions = Omit<Required<Options>, 'resolvers' | 'extensions' | 'dirs' | 'globalComponentsDeclaration'> & {
+  resolvers: ComponentResolverObject[];
+  extensions: string[];
+  dirs: string[];
+  resolvedDirs: string[];
+  globs: string[];
+  globsExclude: string[];
+  dts: string | false;
+  dtsTsx: boolean;
+  root: string;
+};
+type ComponentsImportMap = Record<string, string[] | undefined>;
+interface TypeImport {
+  from: string;
+  names: string[];
+}
+//#endregion
+export { ComponentResolverObject as a, ImportInfoLegacy as c, PublicPluginAPI as d, ResolvedOptions as f, TypeImport as h, ComponentResolverFunction as i, Matcher as l, Transformer as m, ComponentResolveResult as n, ComponentsImportMap as o, SideEffectsInfo as p, ComponentResolver as r, ImportInfo as s, ComponentInfo as t, Options as u };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { a as ComponentResolverObject, c as ImportInfoLegacy, d as PublicPluginAPI, f as ResolvedOptions, h as TypeImport, i as ComponentResolverFunction, l as Matcher, m as Transformer, n as ComponentResolveResult, o as ComponentsImportMap, p as SideEffectsInfo, r as ComponentResolver, s as ImportInfo, t as ComponentInfo, u as Options } from "./types-BbnOeCab.mjs";
+export { ComponentInfo, ComponentResolveResult, ComponentResolver, ComponentResolverFunction, ComponentResolverObject, ComponentsImportMap, ImportInfo, ImportInfoLegacy, Matcher, Options, PublicPluginAPI, ResolvedOptions, SideEffectsInfo, Transformer, TypeImport };

package/dist/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/utils-BfjsfvcK.mjs

@@ -0,0 +1,229 @@
+import process from "node:process";
+import { parse } from "node:path";
+import { getPackageInfo, isPackageExists } from "local-pkg";
+import picomatch from "picomatch";
+//#region node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.mjs
+function toArray(array) {
+	array = array ?? [];
+	return Array.isArray(array) ? array : [array];
+}
+function notNullish(v) {
+	return v != null;
+}
+function slash(str) {
+	return str.replace(/\\/g, "/");
+}
+/**
+* Throttle execution of a function. Especially useful for rate limiting
+* execution of handlers on events like resize and scroll.
+*
+* @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+*                                            are most useful.
+* @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+*                                            as-is, to `callback` when the throttled-function is executed.
+* @param {object} [options] -              An object to configure options.
+* @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+*                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+*                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+*                                            `delay` milliseconds, the internal counter is reset).
+* @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+*                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+*                                            callback will never executed if both noLeading = true and noTrailing = true.
+* @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+*                                            false (at end), schedule `callback` to execute after `delay` ms.
+*
+* @returns {Function} A new, throttled, function.
+*/
+function throttle$1(delay, callback, options) {
+	var _ref = options || {}, _ref$noTrailing = _ref.noTrailing, noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing, _ref$noLeading = _ref.noLeading, noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading, _ref$debounceMode = _ref.debounceMode, debounceMode = _ref$debounceMode === void 0 ? void 0 : _ref$debounceMode;
+	var timeoutID;
+	var cancelled = false;
+	var lastExec = 0;
+	function clearExistingTimeout() {
+		if (timeoutID) clearTimeout(timeoutID);
+	}
+	function cancel(options) {
+		var _ref2$upcomingOnly = (options || {}).upcomingOnly, upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
+		clearExistingTimeout();
+		cancelled = !upcomingOnly;
+	}
+	function wrapper() {
+		for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) arguments_[_key] = arguments[_key];
+		var self = this;
+		var elapsed = Date.now() - lastExec;
+		if (cancelled) return;
+		function exec() {
+			lastExec = Date.now();
+			callback.apply(self, arguments_);
+		}
+		function clear() {
+			timeoutID = void 0;
+		}
+		if (!noLeading && debounceMode && !timeoutID) exec();
+		clearExistingTimeout();
+		if (debounceMode === void 0 && elapsed > delay) if (noLeading) {
+			lastExec = Date.now();
+			if (!noTrailing) timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+		} else exec();
+		else if (noTrailing !== true) timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === void 0 ? delay - elapsed : delay);
+	}
+	wrapper.cancel = cancel;
+	return wrapper;
+}
+function throttle(...args) {
+	return throttle$1(...args);
+}
+//#endregion
+//#region src/core/constants.ts
+const DISABLE_COMMENT = "/* unplugin-vue-components disabled */";
+//#endregion
+//#region src/core/utils.ts
+const isSSR = Boolean(process.env.SSR || process.env.SSG || process.env.VITE_SSR || process.env.VITE_SSG);
+function pascalCase(str) {
+	return capitalize(camelCase(str));
+}
+function camelCase(str) {
+	return str.replace(/-(\w)/g, (_, c) => c ? c.toUpperCase() : "");
+}
+function kebabCase(key) {
+	return key.replace(/([A-Z])/g, " $1").trim().split(" ").join("-").toLowerCase();
+}
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function parseId(id) {
+	const index = id.indexOf("?");
+	if (index < 0) return {
+		path: id,
+		query: {}
+	};
+	else {
+		const query = Object.fromEntries(new URLSearchParams(id.slice(index)));
+		return {
+			path: id.slice(0, index),
+			query
+		};
+	}
+}
+function isEmpty(value) {
+	if (!value || value === null || value === void 0 || Array.isArray(value) && Object.keys(value).length <= 0) return true;
+	else return false;
+}
+function matchGlobs(filepath, globs) {
+	for (const glob of globs) {
+		const isNegated = glob[0] === "!";
+		if (picomatch(isNegated ? glob.slice(1) : glob)(slash(filepath))) return !isNegated;
+	}
+	return false;
+}
+function getTransformedPath(path, importPathTransform) {
+	if (importPathTransform) {
+		const result = importPathTransform(path);
+		if (result != null) path = result;
+	}
+	return path;
+}
+function stringifyImport(info) {
+	if (typeof info === "string") return `import '${info}'`;
+	if (!info.as) return `import '${info.from}'`;
+	else if (info.name) return `import { ${info.name} as ${info.as} } from '${info.from}'`;
+	else return `import ${info.as} from '${info.from}'`;
+}
+function normalizeComponentInfo(info) {
+	if ("path" in info) return {
+		from: info.path,
+		as: info.name,
+		name: info.importName,
+		sideEffects: info.sideEffects
+	};
+	return info;
+}
+function stringifyComponentImport({ as: name, from: path, name: importName, sideEffects }, ctx) {
+	path = getTransformedPath(path, ctx.options.importPathTransform);
+	const imports = [stringifyImport({
+		as: name,
+		from: path,
+		name: importName
+	})];
+	if (sideEffects) toArray(sideEffects).forEach((i) => imports.push(stringifyImport(i)));
+	return imports.join(";");
+}
+function getNameFromFilePath(filePath, options) {
+	const { resolvedDirs, directoryAsNamespace, globalNamespaces, collapseSamePrefixes, root } = options;
+	const parsedFilePath = parse(slash(filePath));
+	let strippedPath = "";
+	for (const dir of resolvedDirs) if (parsedFilePath.dir.startsWith(dir)) {
+		strippedPath = parsedFilePath.dir.slice(dir.length);
+		break;
+	}
+	let folders = strippedPath.slice(1).split("/").filter(Boolean);
+	let filename = parsedFilePath.name;
+	if (filename === "index" && !directoryAsNamespace) {
+		if (isEmpty(folders)) folders = parsedFilePath.dir.slice(root.length + 1).split("/").filter(Boolean);
+		filename = `${folders.slice(-1)[0]}`;
+		return filename;
+	}
+	if (directoryAsNamespace) {
+		if (globalNamespaces.some((name) => folders.includes(name))) folders = folders.filter((f) => !globalNamespaces.includes(f));
+		folders = folders.map((f) => f.replace(/[^a-z0-9\-]/gi, ""));
+		if (filename.toLowerCase() === "index") filename = "";
+		if (!isEmpty(folders)) {
+			let namespaced = [...folders, filename];
+			if (collapseSamePrefixes) {
+				const collapsed = [];
+				for (const fileOrFolderName of namespaced) {
+					let cumulativePrefix = "";
+					let didCollapse = false;
+					const pascalCasedName = pascalCase(fileOrFolderName);
+					for (const parentFolder of [...collapsed].reverse()) {
+						cumulativePrefix = `${parentFolder}${cumulativePrefix}`;
+						if (pascalCasedName.startsWith(cumulativePrefix)) {
+							const collapseSamePrefix = pascalCasedName.slice(cumulativePrefix.length);
+							collapsed.push(collapseSamePrefix);
+							didCollapse = true;
+							break;
+						}
+					}
+					if (!didCollapse) collapsed.push(pascalCasedName);
+				}
+				namespaced = collapsed;
+			}
+			filename = namespaced.filter(Boolean).join("-");
+		}
+		return filename;
+	}
+	return filename;
+}
+function resolveAlias(filepath, alias) {
+	const result = filepath;
+	if (Array.isArray(alias)) for (const { find, replacement } of alias) result.replace(find, replacement);
+	return result;
+}
+async function getPkgVersion(pkgName, defaultVersion) {
+	try {
+		if (isPackageExists(pkgName)) return (await getPackageInfo(pkgName))?.version ?? defaultVersion;
+		else return defaultVersion;
+	} catch (err) {
+		console.error(err);
+		return defaultVersion;
+	}
+}
+function shouldTransform(code) {
+	if (code.includes("/* unplugin-vue-components disabled */")) return false;
+	return true;
+}
+function isExclude(name, exclude) {
+	if (!exclude) return false;
+	if (typeof exclude === "string") return name === exclude;
+	if (exclude instanceof RegExp) return !!name.match(exclude);
+	if (Array.isArray(exclude)) {
+		for (const item of exclude) if (name === item || name.match(item)) return true;
+	}
+	return false;
+}
+const ESCAPE_PARENTHESES_REGEX = /[()]/g;
+function escapeSpecialChars(str) {
+	return str.replace(ESCAPE_PARENTHESES_REGEX, "\\$&");
+}
+//#endregion
+export { notNullish as _, getTransformedPath as a, toArray as b, kebabCase as c, parseId as d, pascalCase as f, DISABLE_COMMENT as g, stringifyComponentImport as h, getPkgVersion as i, matchGlobs as l, shouldTransform as m, escapeSpecialChars as n, isExclude as o, resolveAlias as p, getNameFromFilePath as r, isSSR as s, camelCase as t, normalizeComponentInfo as u, slash as v, throttle as y };

package/dist/vite.d.mts

@@ -0,0 +1,9 @@
+import { d as PublicPluginAPI, u as Options } from "./types-BbnOeCab.mjs";
+import { Plugin } from "vite";
+
+//#region src/vite.d.ts
+declare const vite: (options?: Options | undefined) => Plugin<any> & {
+  api: PublicPluginAPI;
+};
+//#endregion
+export { vite as default, vite as "module.exports" };

package/dist/vite.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin_default } from "./src-S1kwY0Q8.mjs";
+//#region src/vite.ts
+const vite = unplugin_default.vite;
+//#endregion
+export { vite as default, vite as "module.exports" };

package/dist/webpack.d.mts

@@ -0,0 +1,6 @@
+import { u as Options } from "./types-BbnOeCab.mjs";
+
+//#region src/webpack.d.ts
+declare const webpack: (options: Options) => import("webpack").WebpackPluginInstance;
+//#endregion
+export { webpack as default, webpack as "module.exports" };

package/dist/webpack.mjs

@@ -0,0 +1,5 @@
+import { t as unplugin_default } from "./src-S1kwY0Q8.mjs";
+//#region src/webpack.ts
+const webpack = unplugin_default.webpack;
+//#endregion
+export { webpack as default, webpack as "module.exports" };

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@pit-frontend-framework/unplugin-vue-components",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "湖南创智艾泰克科技有限公司-前端组组件自动导入插件库",
+  "author": "湖南创智艾泰克科技有限公司-前端组",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./esbuild": "./dist/esbuild.mjs",
+    "./nuxt": "./dist/nuxt.mjs",
+    "./resolvers": "./dist/resolvers.mjs",
+    "./rolldown": "./dist/rolldown.mjs",
+    "./rollup": "./dist/rollup.mjs",
+    "./rspack": "./dist/rspack.mjs",
+    "./types": "./dist/types.mjs",
+    "./vite": "./dist/vite.mjs",
+    "./webpack": "./dist/webpack.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*.d.mts",
+        "./*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown -w",
+    "example:build": "npm -C examples/vite-vue3 run build",
+    "example:dev": "npm -C examples/vite-vue3 run dev",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint .",
+    "typecheck": "tsgo",
+    "release": "bumpp",
+    "test": "vitest",
+    "test:update": "vitest -u"
+  },
+  "peerDependencies": {
+    "@nuxt/kit": "^3.2.2 || ^4.0.0",
+    "vue": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "local-pkg": "^1.2.0",
+    "magic-string": "^0.30.21",
+    "mlly": "^1.8.2",
+    "obug": "^2.1.1",
+    "picomatch": "^4.0.4",
+    "tinyglobby": "^0.2.16",
+    "unplugin": "^3.0.0",
+    "unplugin-utils": "^0.3.1"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^9.0.0",
+    "@antfu/utils": "^9.3.0",
+    "@nuxt/kit": "^4.4.6",
+    "@nuxt/schema": "^4.4.6",
+    "@types/node": "^25.9.1",
+    "@types/picomatch": "^4.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20260114.1",
+    "bumpp": "^11.1.0",
+    "compare-versions": "^6.1.1",
+    "element-plus": "^2.14.0",
+    "eslint": "^10.4.0",
+    "eslint-plugin-format": "^2.0.1",
+    "pathe": "^2.0.3",
+    "rolldown": "^1.0.1",
+    "rollup": "^4.60.4",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.13",
+    "vitest": "^4.1.6",
+    "vue": "3.2.45",
+    "vue-tsc": "^3.3.1",
+    "webpack": "^5.106.2"
+  },
+  "inlinedDependencies": {
+    "@antfu/utils": "9.3.0",
+    "compare-versions": "6.1.1"
+  }
+}