daren.hsu/line_push
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

拿掉 build files

Browse Source
This commit is contained in:
Pochang Lee
2022-07-18 16:33:23 +08:00
parent 41e2287bcb
commit 3707f158a3
31953 changed files with 0 additions and 4411796 deletions
Download Patch File Download Diff File Expand all files Collapse all files
node_modules/@nuxt/telemetry/dist/cli.js
Generated Vendored
-156
View File
@@ -1,156 +0,0 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var destr = _interopDefault(require('destr'));
var rc = require('rc9');
var meta = require('./meta-73536716.js');
var path = require('path');
var path__default = _interopDefault(path);
var fs = require('fs');
var os = _interopDefault(require('os'));
var consola = _interopDefault(require('consola'));
var c = _interopDefault(require('chalk'));
var stdEnv = _interopDefault(require('std-env'));
var arg = _interopDefault(require('arg'));
var jiti = _interopDefault(require('jiti'));
var dotenv = _interopDefault(require('dotenv'));
const usage = 'nuxt telemetry `status`|`enable`|`disable` [`-g`,`--global`] [`dir`]';
const RC_FILENAME = '.nuxtrc';
function _run() {
const args = arg({
'--global': Boolean,
'-g': '--global'
});
const [command, _dir = '.'] = args._;
const dir = path.resolve(process.cwd(), _dir);
const global = args['--global'];
if (!global && !fs.existsSync(path.resolve(dir, 'nuxt.config.js')) && !fs.existsSync(path.resolve(dir, 'nuxt.config.ts'))) {
consola.error('It seems you are not in a nuxt project!');
consola.info('You can try with providing dir or using `-g`');
showUsage();
}
switch (command) {
case 'enable':
setRC('telemetry.enabled', true);
setRC('telemetry.consent', meta.consentVersion);
showStatus();
consola.info('You can disable telemetry with `npx nuxt telemetry disable ' + (global ? '-g' : _dir));
return;
case 'disable':
setRC('telemetry.enabled', false);
setRC('telemetry.consent', 0);
showStatus();
consola.info('You can enable telemetry with `npx nuxt telemetry enable ' + (global ? '-g' : _dir) + '`');
return;
case 'status':
showStatus();
return;
default:
showUsage();
}
function _checkDisabled() {
// test
if (stdEnv.test) {
return 'Because running in test environment';
} // env
if (destr(process.env.NUXT_TELEMETRY_DISABLED)) {
return 'by `NUXT_TELEMETRY_DISABLED` environment variable';
} // dotenv
const dotenvFile = path.resolve(dir, '.env');
if (fs.existsSync(dotenvFile)) {
const _env = dotenv.parse(fs.readFileSync(dotenvFile));
if (destr(_env.NUXT_TELEMETRY_DISABLED)) {
return 'by `NUXT_TELEMETRY_DISABLED` from ' + dotenvFile;
}
}
const disabledByConf = conf => conf.telemetry === false || conf.telemetry && conf.telemetry.enabled === false; // nuxt.config
try {
const _require = jiti(dir);
if (disabledByConf(_require('./nuxt.config'))) {
return 'by ' + _require.resolve('./nuxt.config');
}
} catch (_) {} // Projct .nuxtrc
if (disabledByConf(rc.read({
name: RC_FILENAME,
dir
}))) {
return 'by ' + path.resolve(dir, RC_FILENAME);
} // Global .nuxtrc
if (disabledByConf(rc.readUser({
name: RC_FILENAME
}))) {
return 'by ' + path.resolve(os.homedir(), RC_FILENAME);
}
}
function showStatus() {
const disabled = _checkDisabled();
if (disabled) {
consola.info(`Nuxt telemetry is ${c.yellow('disabled')} ${disabled}`);
} else {
consola.info(`Nuxt telemetry is ${c.green('enabled')}`, global ? 'on machine' : 'on current project');
}
}
function showUsage() {
consola.info(`Usage: ${usage}`);
process.exit(0);
}
function setRC(key, val) {
const update = {
[key]: val
};
if (global) {
rc.updateUser(update, RC_FILENAME);
} else {
rc.update(update, {
name: RC_FILENAME,
dir
});
}
}
}
function run() {
try {
_run();
} catch (err) {
consola.fatal(err);
process.exit(1);
}
}
if (!module.parent) {
run();
}
exports.run = run;
exports.usage = usage;
node_modules/@nuxt/telemetry/dist/index.d.ts
Generated Vendored
-25
View File
@@ -1,25 +0,0 @@
import { Module } from '@nuxt/types';
interface TelemetryOptions {
debug: boolean
endpoint: string
seed: string
consent?: number
enabled: boolean
}
declare module '@nuxt/types/config/index' {
interface NuxtOptions {
telemetry: boolean | Partial<{
debug: boolean
endpoint: string
seed: string
consent: 1
enabled: boolean
}>
}
}
declare const telemetryModule: Module<TelemetryOptions>;
export default telemetryModule;
node_modules/@nuxt/telemetry/dist/index.js
Generated Vendored
-510
View File
@@ -1,510 +0,0 @@
'use strict';
const destr = require('destr');
const nanoid = require('nanoid');
const rc9 = require('rc9');
const fetch = require('node-fetch');
const path = require('path');
const fs = require('fs');
const createRequire = require('create-require');
const os = require('os');
const gitUrlParse = require('git-url-parse');
const parseGitConfig = require('parse-git-config');
const isDocker = require('is-docker');
const ci = require('ci-info');
const fs$1 = require('fs-extra');
const crypto = require('crypto');
const consola = require('consola');
const c = require('chalk');
const inquirer = require('inquirer');
const stdEnv = require('std-env');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
const destr__default = /*#__PURE__*/_interopDefaultLegacy(destr);
const fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
const createRequire__default = /*#__PURE__*/_interopDefaultLegacy(createRequire);
const os__default = /*#__PURE__*/_interopDefaultLegacy(os);
const gitUrlParse__default = /*#__PURE__*/_interopDefaultLegacy(gitUrlParse);
const parseGitConfig__default = /*#__PURE__*/_interopDefaultLegacy(parseGitConfig);
const isDocker__default = /*#__PURE__*/_interopDefaultLegacy(isDocker);
const ci__default = /*#__PURE__*/_interopDefaultLegacy(ci);
const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
const c__default = /*#__PURE__*/_interopDefaultLegacy(c);
const inquirer__default = /*#__PURE__*/_interopDefaultLegacy(inquirer);
const stdEnv__default = /*#__PURE__*/_interopDefaultLegacy(stdEnv);
var name = "@nuxt/telemetry";
var version = "1.3.6";
function updateUserNuxtRc(key, val) {
rc9.updateUser({[key]: val}, ".nuxtrc");
}
const consentVersion = 1;
async function postEvent(endpoint, body) {
const res = await fetch__default['default'](endpoint, {
method: "POST",
body: JSON.stringify(body),
headers: {
"content-type": "application/json",
"user-agent": "Nuxt Telemetry " + version
},
timeout: 4e3
});
if (!res.ok) {
throw new Error(res.statusText);
}
}
const build = function({nuxt}, payload) {
const duration = {build: payload.duration.build};
let isSuccess = true;
for (const [name, stat] of Object.entries(payload.stats)) {
duration[name] = stat.duration;
if (!stat.success) {
isSuccess = false;
}
}
return {
name: "build",
isSuccess,
isDev: nuxt.options.dev || false,
duration
};
};
const command = function({nuxt}) {
let command2 = "unknown";
const flagMap = {
dev: "dev",
_generate: "generate",
_export: "export",
_build: "build",
_serve: "serve",
_start: "start"
};
for (const flag in flagMap) {
if (nuxt.options[flag]) {
command2 = flagMap[flag];
break;
}
}
return {
name: "command",
command: command2
};
};
const generate = function generate2({nuxt}, payload) {
return {
name: "generate",
isExport: !!nuxt.options._export,
routesCount: payload.routesCount,
duration: {
generate: payload.duration.generate
}
};
};
const dependency = function({nuxt: {options}}) {
const events = [];
const projectDeps = getDependencies(options.rootDir);
const modules = normalizeModules(options.modules);
const buildModules = normalizeModules(options.buildModules);
const relatedDeps = [...modules, ...buildModules];
for (const dep of projectDeps) {
if (!relatedDeps.includes(dep.name)) {
continue;
}
events.push({
name: "dependency",
packageName: dep.name,
version: dep.version,
isDevDependency: dep.dev,
isModule: modules.includes(dep.name),
isBuildModule: buildModules.includes(dep.name)
});
}
return events;
};
function normalizeModules(modules) {
return modules.map((m) => {
if (typeof m === "string") {
return m;
}
if (Array.isArray(m) && typeof m[0] === "string") {
return m[0];
}
return null;
}).filter(Boolean);
}
function getDependencies(rootDir) {
const pkgPath = path.join(rootDir, "package.json");
if (!fs.existsSync(pkgPath)) {
return [];
}
const _require = createRequire__default['default'](rootDir);
const pkg = _require(pkgPath);
const mapDeps = (depsObj, dev = false) => {
const _deps = [];
for (const name in depsObj) {
try {
const pkg2 = _require(path.join(name, "package.json"));
_deps.push({name, version: pkg2.version, dev});
} catch (_e) {
_deps.push({name, version: depsObj[name], dev});
}
}
return _deps;
};
const deps = [];
if (pkg.dependencies) {
deps.push(...mapDeps(pkg.dependencies));
}
if (pkg.devDependencies) {
deps.push(...mapDeps(pkg.dependencies, true));
}
return deps;
}
const project = function(context) {
const {options} = context.nuxt;
return {
name: "project",
type: context.git && context.git.url ? "git" : "local",
isSSR: options.mode === "universal" || options.ssr === true,
target: options._generate ? "static" : "server",
packageManager: context.packageManager
};
};
const session = function({seed}) {
return {
name: "session",
id: seed
};
};
const events = /*#__PURE__*/Object.freeze({
__proto__: null,
build: build,
command: command,
generate: generate,
dependency: dependency,
getDependencies: getDependencies,
project: project,
session: session
});
const FILE2PM = {
"yarn.lock": "yarn",
"package-lock.json": "npm",
"shrinkwrap.json": "npm"
};
async function detectPackageManager(rootDir) {
for (const file in FILE2PM) {
if (await fs__default['default'].pathExists(path__default['default'].resolve(rootDir, file))) {
return FILE2PM[file];
}
}
return "unknown";
}
function hash(str) {
return crypto.createHash("sha256").update(str).digest("hex").substr(0, 16);
}
async function createContext(nuxt, options) {
const rootDir = nuxt.options.rootDir || process.cwd();
const git = await getGit(rootDir);
const packageManager = await detectPackageManager(rootDir);
const {seed} = options;
const projectHash = await getProjectHash(rootDir, git, seed);
const projectSession = getProjectSession(projectHash, seed);
const nuxtVersion = (nuxt.constructor.version || "").replace("v", "");
const nodeVersion = process.version.replace("v", "");
const isEdge = nuxtVersion.includes("-");
return {
nuxt,
seed,
git,
projectHash,
projectSession,
nuxtVersion,
isEdge,
cli: getCLI(),
nodeVersion,
os: os__default['default'].type().toLocaleLowerCase(),
environment: getEnv(),
packageManager,
concent: options.consent
};
}
function getEnv() {
if (process.env.CODESANDBOX_SSE) {
return "CSB";
}
if (ci__default['default'].isCI) {
return ci__default['default'].name;
}
if (isDocker__default['default']()) {
return "Docker";
}
return "unknown";
}
function getCLI() {
let entry;
if (typeof require !== "undefined" && require.main && require.main.filename) {
entry = require.main.filename;
} else {
entry = process.argv[1];
}
const knownCLIs = {
"nuxt-ts.js": "nuxt-ts",
"nuxt-start.js": "nuxt-start",
"nuxt.js": "nuxt"
};
for (const key in knownCLIs) {
if (entry.includes(key)) {
const edge = entry.includes("-edge") ? "-edge" : "";
return knownCLIs[key] + edge;
}
}
return "programmatic";
}
function getProjectSession(projectHash, sessionId) {
return hash(`${projectHash}#${sessionId}`);
}
function getProjectHash(rootDir, git, seed) {
let id;
if (git && git.url) {
id = `${git.source}#${git.owner}#${git.name}`;
} else {
id = `${rootDir}#${seed}`;
}
return hash(id);
}
async function getGitRemote(rootDir) {
try {
const parsed = await parseGitConfig__default['default']({cwd: rootDir});
if (parsed) {
const gitRemote = parsed['remote "origin"'].url;
return gitRemote;
}
return null;
} catch (err) {
return null;
}
}
async function getGit(rootDir) {
const gitRemote = await getGitRemote(rootDir);
if (!gitRemote) {
return;
}
const meta = gitUrlParse__default['default'](gitRemote);
const url = meta.toString("https");
return {
url,
gitRemote,
source: meta.source,
owner: meta.owner,
name: meta.name
};
}
const log = consola__default['default'].withScope("@nuxt/telemetry");
class Telemetry {
constructor(nuxt, options) {
this.events = [];
this.nuxt = nuxt;
this.options = options;
}
getContext() {
if (!this._contextPromise) {
this._contextPromise = createContext(this.nuxt, this.options);
}
return this._contextPromise;
}
createEvent(name, payload) {
const eventFactory = events[name];
if (typeof eventFactory !== "function") {
log.warn("Unknown event:", name);
return;
}
const eventPromise = this._invokeEvent(name, eventFactory, payload);
this.events.push(eventPromise);
}
async _invokeEvent(name, eventFactory, payload) {
try {
const context = await this.getContext();
const event = await eventFactory(context, payload);
event.name = name;
return event;
} catch (err) {
log.error("Error while running event:", err);
}
}
async getPublicContext() {
const context = await this.getContext();
const eventContext = {};
for (const key of [
"nuxtVersion",
"isEdge",
"nodeVersion",
"cli",
"os",
"environment",
"projectHash",
"projectSession"
]) {
eventContext[key] = context[key];
}
return eventContext;
}
async sendEvents() {
const events2 = [].concat(...(await Promise.all(this.events)).filter(Boolean));
this.events = [];
const context = await this.getPublicContext();
const body = {
timestamp: Date.now(),
context,
events: events2
};
if (this.options.endpoint) {
const start = Date.now();
try {
log.info("Sending events:", JSON.stringify(body, null, 2));
await postEvent(this.options.endpoint, body);
log.success(`Events sent to \`${this.options.endpoint}\` (${Date.now() - start} ms)`);
} catch (err) {
log.error(`Error sending sent to \`${this.options.endpoint}\` (${Date.now() - start} ms)
`, err);
}
}
}
}
function getStats(stats) {
const duration = stats.endTime - stats.startTime;
return {
duration,
success: stats.compilation.errors.length === 0,
size: 0,
fullHash: stats.compilation.fullHash
};
}
async function ensureUserconsent(options) {
if (options.consent >= consentVersion) {
return true;
}
if (stdEnv__default['default'].minimal || process.env.CODESANDBOX_SSE || process.env.NEXT_TELEMETRY_DISABLED || isDocker__default['default']()) {
return false;
}
process.stdout.write("\n");
consola__default['default'].info(`${c__default['default'].green("NuxtJS")} collects completely anonymous data about usage.
This will help us improve Nuxt developer experience over time.
Read more on ${c__default['default'].cyan.underline("https://git.io/nuxt-telemetry")}
`);
const {accept} = await inquirer__default['default'].prompt({
type: "confirm",
name: "accept",
message: "Are you interested in participating?"
});
process.stdout.write("\n");
if (accept) {
updateUserNuxtRc("telemetry.consent", consentVersion);
updateUserNuxtRc("telemetry.enabled", true);
return true;
}
updateUserNuxtRc("telemetry.enabled", false);
return false;
}
async function _telemetryModule(nuxt) {
const toptions = {
endpoint: destr__default['default'](process.env.NUXT_TELEMETRY_ENDPOINT) || "https://telemetry.nuxtjs.com",
debug: destr__default['default'](process.env.NUXT_TELEMETRY_DEBUG),
...nuxt.options.telemetry
};
if (!toptions.debug) {
log.level = -Infinity;
}
if (nuxt.options.telemetry !== true) {
if (toptions.enabled === false || nuxt.options.telemetry === false || !await ensureUserconsent(toptions)) {
log.info("Telemetry disabled");
return;
}
}
log.info("Telemetry enabled");
if (!toptions.seed) {
toptions.seed = hash(nanoid.nanoid());
updateUserNuxtRc("telemetry.seed", toptions.seed);
log.info("Seed generated:", toptions.seed);
}
const t = new Telemetry(nuxt, toptions);
if (nuxt.options._start) {
nuxt.hook("listen", () => {
t.createEvent("project");
t.createEvent("session");
t.createEvent("command");
t.sendEvents();
});
}
nuxt.hook("build:before", () => {
t.createEvent("project");
t.createEvent("session");
t.createEvent("command");
t.createEvent("dependency");
});
profile(nuxt, t);
}
const telemetryModule = async function() {
try {
await _telemetryModule(this.nuxt);
} catch (err) {
log.error(err);
}
};
function profile(nuxt, t) {
const startT = {};
const duration = {};
const stats = {};
let routesCount = 0;
const timeStart = (name2) => {
startT[name2] = Date.now();
};
const timeEnd = (name2) => {
duration[name2] = Date.now() - startT[name2];
};
nuxt.hook("build:before", () => {
timeStart("build");
});
nuxt.hook("build:done", () => {
timeEnd("build");
});
nuxt.hook("build:compiled", ({name: name2, stats: _stats}) => {
stats[name2] = getStats(_stats);
});
nuxt.hook("generate:extendRoutes", () => timeStart("generate"));
nuxt.hook("generate:routeCreated", () => {
routesCount++;
});
nuxt.hook("generate:done", () => {
timeEnd("generate");
t.createEvent("generate", {duration, stats, routesCount});
t.sendEvents();
});
nuxt.hook("build:done", () => {
t.createEvent("build", {duration, stats});
t.sendEvents();
});
}
telemetryModule.meta = {name, version};
module.exports = telemetryModule;
node_modules/@nuxt/telemetry/dist/meta-73536716.js
Generated Vendored
-5
View File
@@ -1,5 +0,0 @@
'use strict';
const consentVersion = 1;
exports.consentVersion = consentVersion;
node_modules/@nuxt/telemetry/dist/module.js
Generated Vendored
-606
View File
@@ -1,606 +0,0 @@
'use strict';
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var destr = _interopDefault(require('destr'));
var nanoid = require('nanoid');
var rc = require('rc9');
var fetch = _interopDefault(require('node-fetch'));
var meta = require('./meta-73536716.js');
var path = require('path');
var path__default = _interopDefault(path);
var fs = require('fs');
var createRequire = _interopDefault(require('create-require'));
var os = _interopDefault(require('os'));
var gitUrlParse = _interopDefault(require('git-url-parse'));
var parseGitConfig = _interopDefault(require('parse-git-config'));
var isDocker = _interopDefault(require('is-docker'));
var ci = _interopDefault(require('ci-info'));
var fs$1 = _interopDefault(require('fs-extra'));
var crypto = require('crypto');
var consola = _interopDefault(require('consola'));
var c = _interopDefault(require('chalk'));
var inquirer = _interopDefault(require('inquirer'));
var stdEnv = _interopDefault(require('std-env'));
var name = "@nuxt/telemetry";
var version = "1.2.2";
function updateUserNuxtRc(key, val) {
rc.updateUser({
[key]: val
}, '.nuxtrc');
}
async function postEvent(endpoint, body) {
const res = await fetch(endpoint, {
method: 'POST',
body: JSON.stringify(body),
headers: {
'content-type': 'application/json',
'user-agent': 'Nuxt Telemetry ' + version
},
timeout: 4000 // Important: should be less than 5 seconds for prod
});
if (!res.ok) {
throw new Error(res.statusText);
}
}
const build = function ({
nuxt
}, payload) {
const duration = {
build: payload.duration.build
}; // const size = {}
let isSuccess = true;
for (const [name, stat] of Object.entries(payload.stats)) {
duration[name] = stat.duration; // size[name] = stat.size
if (!stat.success) {
isSuccess = false;
}
}
return {
name: 'build',
isSuccess,
isDev: nuxt.options.dev || false,
duration // size
};
};
const command = function ({
nuxt
}) {
let command = 'unknown';
const flagMap = {
dev: 'dev',
_generate: 'generate',
_export: 'export',
_build: 'build',
_serve: 'serve',
_start: 'start'
};
for (const flag in flagMap) {
if (nuxt.options[flag]) {
command = flagMap[flag];
break;
}
}
return {
name: 'command',
command
};
};
const generate = function generate({
nuxt
}, payload) {
return {
name: 'generate',
isExport: !!nuxt.options._export,
routesCount: payload.routesCount,
duration: {
generate: payload.duration.generate
}
};
};
const dependency = function ({
nuxt: {
options
}
}) {
const events = [];
const projectDeps = getDependencies(options.rootDir); // Get used modules and buildModules
const modules = normalizeModules(options.modules);
const buildModules = normalizeModules(options.buildModules); // Only send event for relevant dependencies
const relatedDeps = [...modules, ...buildModules];
for (const dep of projectDeps) {
if (!relatedDeps.includes(dep.name)) {
continue;
}
events.push({
name: 'dependency',
packageName: dep.name,
version: dep.version,
isDevDependency: dep.dev,
isModule: modules.includes(dep.name),
isBuildModule: buildModules.includes(dep.name)
});
}
return events;
};
function normalizeModules(modules) {
return modules.map(m => {
if (typeof m === 'string') {
return m;
}
if (Array.isArray(m) && typeof m[0] === 'string') {
return m[0];
}
}).filter(Boolean);
}
function getDependencies(rootDir) {
const pkgPath = path.join(rootDir, 'package.json');
if (!fs.existsSync(pkgPath)) {
return [];
}
const _require = createRequire(rootDir);
const pkg = _require(pkgPath);
const mapDeps = (depsObj, dev = false) => {
const _deps = [];
for (const name in depsObj) {
try {
const pkg = _require(path.join(name, 'package.json'));
_deps.push({
name,
version: pkg.version,
dev
});
} catch (_e) {
// Dependency is not installed
_deps.push({
name,
version: depsObj[name],
dev
});
}
}
return _deps;
};
const deps = [];
if (pkg.dependencies) {
deps.push(...mapDeps(pkg.dependencies));
}
if (pkg.devDependencies) {
deps.push(...mapDeps(pkg.dependencies, true));
}
return deps;
}
const project = function (context) {
const {
options
} = context.nuxt;
return {
name: 'project',
type: context.git && context.git.url ? 'git' : 'local',
isSSR: options.mode === 'universal' || options.ssr === true,
target: options._generate ? 'static' : 'server',
packageManager: context.packageManager
};
};
const session = function ({
seed
}) {
return {
name: 'session',
id: seed
};
};
var events = /*#__PURE__*/Object.freeze({
__proto__: null,
build: build,
command: command,
generate: generate,
dependency: dependency,
getDependencies: getDependencies,
project: project,
session: session
});
const FILE2PM = {
'yarn.lock': 'yarn',
'package-lock.json': 'npm',
'shrinkwrap.json': 'npm'
};
async function detectPackageManager(rootDir) {
for (const file in FILE2PM) {
if (await fs$1.pathExists(path__default.resolve(rootDir, file))) {
// @ts-ignore
return FILE2PM[file];
}
}
return 'unknown';
}
function hash(str) {
return crypto.createHash('sha256').update(str).digest('hex').substr(0, 16);
}
async function createContext(nuxt, options) {
const rootDir = nuxt.options.rootDir || process.cwd();
const git = await getGit(rootDir);
const packageManager = await detectPackageManager(rootDir);
const {
seed
} = options;
const projectHash = await getProjectHash(rootDir, git, seed);
const projectSession = getProjectSession(projectHash, seed);
const nuxtVersion = (nuxt.constructor.version || '').replace('v', '');
const nodeVersion = process.version.replace('v', '');
const isEdge = nuxtVersion.includes('-');
return {
nuxt,
seed,
git,
projectHash,
projectSession,
nuxtVersion,
isEdge,
cli: getCLI(),
nodeVersion,
os: os.type().toLocaleLowerCase(),
environment: getEnv(),
packageManager
};
}
function getEnv() {
if (process.env.CODESANDBOX_SSE) {
return 'CSB';
}
if (ci.isCI) {
return ci.name;
}
if (isDocker()) {
return 'Docker';
}
return 'unknown';
}
function getCLI() {
const entry = require.main.filename;
const knownCLIs = {
'nuxt-ts.js': 'nuxt-ts',
'nuxt-start.js': 'nuxt-start',
'nuxt.js': 'nuxt'
};
for (const key in knownCLIs) {
if (entry.includes(key)) {
const edge = entry.includes('-edge') ? '-edge' : '';
return knownCLIs[key] + edge;
}
}
return 'programmatic';
}
function getProjectSession(projectHash, sessionId) {
return hash(`${projectHash}#${sessionId}`);
}
function getProjectHash(rootDir, git, seed) {
let id;
if (git && git.url) {
id = `${git.source}#${git.owner}#${git.name}`;
} else {
id = `${rootDir}#${seed}`;
}
return hash(id);
}
async function getGitRemote(rootDir) {
try {
const parsed = await parseGitConfig({
cwd: rootDir
});
if (parsed) {
const gitRemote = parsed['remote "origin"'].url;
return gitRemote;
}
return null;
} catch (err) {
return null;
}
}
async function getGit(rootDir) {
const gitRemote = await getGitRemote(rootDir);
if (!gitRemote) {
return;
}
const meta = gitUrlParse(gitRemote);
const url = meta.toString('https');
return {
url,
gitRemote,
source: meta.source,
owner: meta.owner,
name: meta.name
};
}
var log = consola.withScope('@nuxt/telemetry');
class Telemetry {
constructor(nuxt, options) {
this.events = [];
this.nuxt = nuxt;
this.options = options;
}
getContext() {
if (!this._contextPromise) {
this._contextPromise = createContext(this.nuxt, this.options);
}
return this._contextPromise;
}
createEvent(name, payload) {
// @ts-ignore
const eventFactory = events[name];
if (typeof eventFactory !== 'function') {
log.warn('Unknown event:', name);
return;
}
const eventPromise = this._invokeEvent(name, eventFactory, payload);
this.events.push(eventPromise);
}
async _invokeEvent(name, eventFactory, payload) {
try {
const context = await this.getContext();
const event = await eventFactory(context, payload);
event.name = name;
return event;
} catch (err) {
log.error('Error while running event:', err);
}
}
async getPublicContext() {
const context = await this.getContext();
const eventContext = {};
for (const key of ['nuxtVersion', 'isEdge', 'nodeVersion', 'cli', 'os', 'environment', 'projectHash', 'projectSession']) {
eventContext[key] = context[key];
}
return eventContext;
}
async sendEvents() {
const events = [].concat(...(await Promise.all(this.events)).filter(Boolean));
this.events = [];
const context = await this.getPublicContext();
const body = {
timestamp: Date.now(),
context,
events
};
if (this.options.endpoint) {
const start = Date.now();
try {
log.info('Sending events:', JSON.stringify(body, null, 2));
await postEvent(this.options.endpoint, body);
log.success(`Events sent to \`${this.options.endpoint}\` (${Date.now() - start} ms)`);
} catch (err) {
log.error(`Error sending sent to \`${this.options.endpoint}\` (${Date.now() - start} ms)\n`, err);
}
}
}
}
function getStats(stats) {
const duration = stats.endTime - stats.startTime;
return {
duration,
success: stats.compilation.errors.length === 0,
size: 0,
fullHash: stats.compilation.fullHash
};
}
async function ensureUserconsent(options) {
if (options.consent >= meta.consentVersion || stdEnv.minimal || process.env.CODESANDBOX_SSE || isDocker()) {
return true;
}
process.stdout.write('\n');
consola.info(`${c.green('NuxtJS')} collects completely anonymous data about usage.
This will help us improving Nuxt developer experience over the time.
Read more on ${c.cyan.underline('https://git.io/nuxt-telemetry')}\n`);
const {
accept
} = await inquirer.prompt({
type: 'confirm',
name: 'accept',
message: 'Are you interested in participation?'
});
process.stdout.write('\n');
if (accept) {
updateUserNuxtRc('telemetry.consent', meta.consentVersion);
updateUserNuxtRc('telemetry.enabled', true);
return true;
}
updateUserNuxtRc('telemetry.enabled', false);
return false;
}
async function _telemetryModule(nuxt) {
const toptions = {
endpoint: destr(process.env.NUXT_TELEMETRY_ENDPOINT) || 'https://telemetry.nuxtjs.com',
debug: destr(process.env.NUXT_TELEMETRY_DEBUG),
...nuxt.options.telemetry
};
if (!toptions.debug) {
log.level = -Infinity;
}
if (nuxt.options.telemetry !== true) {
if (toptions.enabled === false || nuxt.options.telemetry === false || !(await ensureUserconsent(toptions))) {
log.info('Telemetry disabled');
return;
}
}
log.info('Telemetry enabled');
if (!toptions.seed) {
toptions.seed = hash(nanoid.nanoid());
updateUserNuxtRc('telemetry.seed', toptions.seed);
log.info('Seed generated:', toptions.seed);
}
const t = new Telemetry(nuxt, toptions);
if (nuxt.options._start) {
// nuxt start
nuxt.hook('listen', () => {
t.createEvent('project');
t.createEvent('session');
t.createEvent('command');
t.sendEvents();
});
}
nuxt.hook('build:before', () => {
t.createEvent('project');
t.createEvent('session');
t.createEvent('command');
t.createEvent('dependency');
});
profile(nuxt, t);
}
async function telemetryModule() {
try {
await _telemetryModule(this.nuxt);
} catch (err) {
log.error(err);
}
}
function profile(nuxt, t) {
const startT = {};
const duration = {};
const stats = {};
let routesCount = 0;
const timeStart = name => {
startT[name] = Date.now();
};
const timeEnd = name => {
duration[name] = Date.now() - startT[name];
}; // Total build timing
nuxt.hook('build:before', () => {
timeStart('build');
});
nuxt.hook('build:done', () => {
timeEnd('build');
});
nuxt.hook('build:compiled', ({
name,
stats: _stats
}) => {
// @ts-ignore
stats[name] = getStats(_stats);
}); // Generate timing
// TODO: workaround as generate:before is before build
nuxt.hook('generate:extendRoutes', () => timeStart('generate'));
nuxt.hook('generate:routeCreated', () => {
routesCount++;
});
nuxt.hook('generate:done', () => {
timeEnd('generate'); // nuxt generate or nuxt export
t.createEvent('generate', {
duration,
stats,
routesCount
});
t.sendEvents();
}); // Report build time
nuxt.hook('build:done', () => {
// nuxt build or nuxt dev
t.createEvent('build', {
duration,
stats
});
t.sendEvents();
});
}
telemetryModule.meta = {
name,
version
};
module.exports = telemetryModule;