%PDF-
%PDF-
Mini Shell
Mini Shell
'use strict';
const fs = require('fs');
const path = require('upath');
const chokidar = require('chokidar');
const chalk = require('chalk');
const semver = require('semver');
const globby = require('globby');
const scule = require('scule');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
const chokidar__default = /*#__PURE__*/_interopDefaultLegacy(chokidar);
const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
const semver__default = /*#__PURE__*/_interopDefaultLegacy(semver);
const globby__default = /*#__PURE__*/_interopDefaultLegacy(globby);
function requireNuxtVersion(currentVersion, requiredVersion) {
const pkgName = require("../package.json").name;
if (!currentVersion || !requireNuxtVersion) {
return;
}
const _currentVersion = semver__default['default'].coerce(currentVersion);
const _requiredVersion = semver__default['default'].coerce(requiredVersion);
if (semver__default['default'].lt(_currentVersion, _requiredVersion)) {
throw new Error(`
${chalk__default['default'].cyan(pkgName)} is not compatible with your current Nuxt version : ${chalk__default['default'].yellow("v" + currentVersion)}
Required: ${chalk__default['default'].green("v" + requiredVersion)} or ${chalk__default['default'].cyan("higher")}
`);
}
}
function sortDirsByPathLength({path: pathA}, {path: pathB}) {
return pathB.split(/[\\/]/).filter(Boolean).length - pathA.split(/[\\/]/).filter(Boolean).length;
}
function hyphenate(str) {
return str.replace(/\B([A-Z])/g, "-$1").toLowerCase();
}
async function scanComponents(dirs, srcDir) {
const components = [];
const filePaths = new Set();
const scannedPaths = [];
for (const {path: path$1, pattern, ignore = [], prefix, extendComponent, pathPrefix, level} of dirs.sort(sortDirsByPathLength)) {
const resolvedNames = new Map();
for (const _file of await globby__default['default'](pattern, {cwd: path$1, ignore})) {
const filePath = path.join(path$1, _file);
if (scannedPaths.find((d) => filePath.startsWith(d))) {
continue;
}
if (filePaths.has(filePath)) {
continue;
}
filePaths.add(filePath);
const prefixParts = [].concat(prefix ? scule.splitByCase(prefix) : [], pathPrefix !== false ? scule.splitByCase(path.relative(path$1, path.dirname(filePath))) : []);
let fileName = path.basename(filePath, path.extname(filePath));
if (fileName.toLowerCase() === "index") {
fileName = pathPrefix === false ? path.basename(path.dirname(filePath)) : "";
}
const fileNameParts = scule.splitByCase(fileName);
const componentNameParts = [];
while (prefixParts.length && (prefixParts[0] || "").toLowerCase() !== (fileNameParts[0] || "").toLowerCase()) {
componentNameParts.push(prefixParts.shift());
}
const componentName = scule.pascalCase(componentNameParts) + scule.pascalCase(fileNameParts);
if (resolvedNames.has(componentName)) {
console.warn(`Two component files resolving to the same name \`${componentName}\`:
- ${filePath}
- ${resolvedNames.get(componentName)}`);
continue;
}
resolvedNames.set(componentName, filePath);
const pascalName = scule.pascalCase(componentName);
const kebabName = hyphenate(componentName);
const shortPath = path.relative(srcDir, filePath);
const chunkName = "components/" + kebabName;
let component = {
filePath,
pascalName,
kebabName,
chunkName,
shortPath,
import: "",
asyncImport: "",
export: "default",
global: Boolean(global),
level: Number(level)
};
if (typeof extendComponent === "function") {
component = await extendComponent(component) || component;
}
component.import = component.import || `require('${component.filePath}').${component.export}`;
component.asyncImport = component.asyncImport || `function () { return import('${component.filePath}' /* webpackChunkName: "${component.chunkName}" */).then(function(m) { return m['${component.export}'] || m }) }`;
const definedComponent = components.find((c) => c.pascalName === component.pascalName);
if (definedComponent && component.level < definedComponent.level) {
Object.assign(definedComponent, component);
} else if (!definedComponent) {
components.push(component);
}
}
scannedPaths.push(path$1);
}
return components;
}
const isPureObjectOrString = (val) => !Array.isArray(val) && typeof val === "object" || typeof val === "string";
const getDir = (p) => fs__default['default'].statSync(p).isDirectory() ? p : path__default['default'].dirname(p);
const componentsModule = function() {
var _a;
const {nuxt} = this;
const {components} = nuxt.options;
if (!components) {
return;
}
requireNuxtVersion((_a = nuxt == null ? void 0 : nuxt.constructor) == null ? void 0 : _a.version, "2.10");
const options = {
dirs: ["~/components"],
loader: !nuxt.options.dev,
...Array.isArray(components) ? {dirs: components} : components
};
nuxt.hook("build:before", async (builder) => {
const nuxtIgnorePatterns = builder.ignore.ignore ? builder.ignore.ignore._rules.map((rule) => rule.pattern) : [];
await nuxt.callHook("components:dirs", options.dirs);
const resolvePath = (dir) => nuxt.resolver.resolvePath(dir);
try {
const globalDir = getDir(resolvePath("~/components/global"));
if (!options.dirs.find((dir) => resolvePath(dir) === globalDir)) {
options.dirs.push({
path: globalDir
});
}
} catch (err) {
nuxt.options.watch.push(path__default['default'].resolve(nuxt.options.srcDir, "components", "global"));
}
const componentDirs = options.dirs.filter(isPureObjectOrString).map((dir) => {
const dirOptions = typeof dir === "object" ? dir : {path: dir};
let dirPath = dirOptions.path;
try {
dirPath = getDir(nuxt.resolver.resolvePath(dirOptions.path));
} catch (err) {
}
const transpile = typeof dirOptions.transpile === "boolean" ? dirOptions.transpile : "auto";
dirOptions.level = Number(dirOptions.level || 0);
const enabled = fs__default['default'].existsSync(dirPath);
if (!enabled && dirOptions.path !== "~/components") {
console.warn("Components directory not found: `" + dirPath + "`");
}
const extensions = dirOptions.extensions || builder.supportedExtensions;
return {
...dirOptions,
enabled,
path: dirPath,
extensions,
pattern: dirOptions.pattern || `**/*.{${extensions.join(",")},}`,
ignore: [
"**/*.stories.{js,ts,jsx,tsx}",
"**/*{M,.m,-m}ixin.{js,ts,jsx,tsx}",
"**/*.d.ts",
...nuxtIgnorePatterns,
...dirOptions.ignore || []
],
transpile: transpile === "auto" ? dirPath.includes("node_modules") : transpile
};
}).filter((d) => d.enabled);
nuxt.options.build.transpile.push(...componentDirs.filter((dir) => dir.transpile).map((dir) => dir.path));
let components2 = await scanComponents(componentDirs, nuxt.options.srcDir);
await nuxt.callHook("components:extend", components2);
if (options.loader) {
console.info("Using components loader to optimize imports");
this.extendBuild((config) => {
var _a2;
const vueRule = (_a2 = config.module) == null ? void 0 : _a2.rules.find((rule) => {
var _a3;
return (_a3 = rule.test) == null ? void 0 : _a3.toString().includes(".vue");
});
if (!vueRule) {
throw new Error("Cannot find vue loader");
}
if (!vueRule.use) {
vueRule.use = [{
loader: vueRule.loader.toString(),
options: vueRule.options
}];
delete vueRule.loader;
delete vueRule.options;
}
if (!Array.isArray(vueRule.use)) {
vueRule.use = [vueRule.use];
}
vueRule.use.unshift({
loader: require.resolve("./loader"),
options: {
getComponents: () => components2
}
});
});
nuxt.hook("webpack:config", (configs) => {
for (const config of configs.filter((c) => ["client", "modern", "server"].includes(c.name))) {
config.entry.app.unshift(path__default['default'].resolve(__dirname, "../lib/installComponents.js"));
}
});
}
if (nuxt.options.dev && componentDirs.some((dir) => dir.watch !== false)) {
const watcher = chokidar__default['default'].watch(componentDirs.filter((dir) => dir.watch !== false).map((dir) => dir.path), nuxt.options.watchers.chokidar);
watcher.on("all", async (eventName) => {
if (!["add", "unlink"].includes(eventName)) {
return;
}
components2 = await scanComponents(componentDirs, nuxt.options.srcDir);
await nuxt.callHook("components:extend", components2);
await builder.generateRoutesAndFiles();
});
nuxt.hook("close", () => {
watcher.close();
});
}
const getComponents = () => components2;
const templates = [
"components/index.js",
"components/plugin.js",
"components/utils.js",
"components/readme_md",
"vetur/tags.json"
];
for (const t of templates) {
this[t.includes("plugin") ? "addPlugin" : "addTemplate"]({
src: path__default['default'].resolve(__dirname, "../templates", t),
fileName: t.replace("_", "."),
options: {getComponents}
});
}
const componentsListFile = path__default['default'].resolve(nuxt.options.buildDir, "components/readme.md");
console.info("Discovered Components:", path__default['default'].relative(process.cwd(), componentsListFile));
});
};
componentsModule.meta = {name: "@nuxt/components"};
module.exports = componentsModule;
Zerion Mini Shell 1.0