@chromatic-com/vitest 0.1.9 → 0.1.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,14 +1,14 @@
1
1
  #!/usr/bin/env node
2
- var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
2
+ var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
3
3
  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
4
- }) : x)(function(x) {
4
+ }) : x2)(function(x2) {
5
5
  if (typeof require !== "undefined")
6
6
  return require.apply(this, arguments);
7
- throw Error('Dynamic require of "' + x + '" is not supported');
7
+ throw Error('Dynamic require of "' + x2 + '" is not supported');
8
8
  });
9
9
 
10
10
  // ../shared/src/archive-storybook/index.ts
11
- import { execFileSync } from "child_process";
11
+ import { spawn } from "child_process";
12
12
  import { resolve, dirname } from "path";
13
13
  import { readFileSync } from "fs";
14
14
  import { createRequire } from "module";
@@ -40,9 +40,35 @@ Please make sure that you have run your E2E tests, or have set the CHROMATIC_ARC
40
40
 
41
41
  // ../shared/src/archive-storybook/index.ts
42
42
  var req = __require.resolve ? __require : createRequire(import.meta.url);
43
- function archiveStorybook(processArgs, configDir2, defaultOutputDir) {
44
- checkArchivesDirExists(defaultOutputDir);
45
- execFileSync("node", [binPath(), "dev", ...processArgs, "-c", configDir2], { stdio: "inherit" });
43
+ async function archiveStorybook(processArgs, configDir2, defaultOutputDir, callbacks) {
44
+ assertOutputDirectory(defaultOutputDir, callbacks);
45
+ await runBin([binPath(), "dev", ...processArgs, "-c", configDir2]);
46
+ }
47
+ function assertOutputDirectory(outputDirectory, callbacks) {
48
+ try {
49
+ checkArchivesDirExists(outputDirectory);
50
+ } catch (error) {
51
+ callbacks?.onArchivesCheck(error);
52
+ throw error;
53
+ }
54
+ callbacks?.onArchivesCheck();
55
+ }
56
+ function runBin(args2) {
57
+ return new Promise((resolvePromise, reject) => {
58
+ const child = spawn("node", args2, { stdio: "inherit" });
59
+ child.on("error", reject);
60
+ child.on("close", (code, signal) => {
61
+ if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
62
+ resolvePromise();
63
+ } else {
64
+ reject(
65
+ Object.assign(new Error(`Storybook exited with ${signal ?? `code ${code}`}`), {
66
+ status: code
67
+ })
68
+ );
69
+ }
70
+ });
71
+ });
46
72
  }
47
73
  function binPath() {
48
74
  const filename = req.resolve("storybook/package.json");
@@ -56,12 +82,287 @@ import path2 from "path";
56
82
  // src/constants.ts
57
83
  var DEFAULT_OUTPUT_DIR = ".vitest/chromatic";
58
84
 
85
+ // src/node/telemetry/constants.ts
86
+ var EVENT_TYPE_PREFIX = "vitest_";
87
+ var TELEMETRY_FETCH_TIMEOUT_MS = 5e3;
88
+ var TELEMETRY_URL = "https://analytics.chromatic.com";
89
+ var TELEMETRY_LOG_FILE = "telemetry.jsonl";
90
+ var TELEMETRY_METADATA_FILE = "telemetry-metadata.json";
91
+
92
+ // src/node/telemetry/env.ts
93
+ import { readFileSync as readFileSync2 } from "node:fs";
94
+ import { resolve as resolve2 } from "node:path";
95
+ import util from "node:util";
96
+ import { env } from "std-env";
97
+ var dotEnv = void 0;
98
+ function getEnv(name) {
99
+ if (dotEnv === void 0) {
100
+ if (typeof util.parseEnv !== "function") {
101
+ dotEnv = {};
102
+ } else {
103
+ try {
104
+ dotEnv = util.parseEnv(readFileSync2(resolve2(process.cwd(), ".env"), "utf8"));
105
+ } catch {
106
+ dotEnv = {};
107
+ }
108
+ }
109
+ }
110
+ return env[name] ?? dotEnv[name];
111
+ }
112
+ function resolveTelemetryOptions() {
113
+ return {
114
+ // Enabled by default, disabled by env variables
115
+ enabled: isTruthyEnv(getEnv("CHROMATIC_DISABLE_TELEMETRY")) === false && isTruthyEnv(getEnv("DO_NOT_TRACK")) === false,
116
+ // Disabled by default, enabled by env variable
117
+ logToFile: isTruthyEnv(getEnv("CHROMATIC_TELEMETRY_LOG_TO_FILE"))
118
+ };
119
+ }
120
+ function isTruthyEnv(value) {
121
+ return value !== void 0 && value !== "" && value !== "0" && value !== "false";
122
+ }
123
+
124
+ // src/node/telemetry/track.ts
125
+ import { randomUUID as randomUUID2 } from "node:crypto";
126
+ import { appendFile, mkdir } from "node:fs/promises";
127
+ import { resolve as resolve4 } from "node:path";
128
+ import { isCI, nodeVersion } from "std-env";
129
+
130
+ // package.json
131
+ var version = "0.1.10";
132
+
133
+ // src/node/telemetry/metadata.ts
134
+ import { createHash } from "node:crypto";
135
+ import { existsSync as existsSync2 } from "node:fs";
136
+ import { writeFile, readFile } from "node:fs/promises";
137
+ import { createRequire as createRequire2 } from "node:module";
138
+ import { join, resolve as resolve3 } from "node:path";
139
+ import { x } from "tinyexec";
140
+ import { env as env2 } from "std-env";
141
+ var userAgentMatch = env2.npm_config_user_agent?.match(/^([^/\s]+)\/(\S+)/);
142
+ var packageManager = {
143
+ name: userAgentMatch?.[1] || "unknown",
144
+ version: userAgentMatch?.[2] || "unknown"
145
+ };
146
+ async function createProjectId(root) {
147
+ let remote = void 0;
148
+ try {
149
+ const result = await x("git", ["remote", "get-url", "origin"], { nodeOptions: { cwd: root } });
150
+ remote = result.exitCode === 0 ? result.stdout.trim().toLowerCase() : void 0;
151
+ } catch {
152
+ }
153
+ if (!remote) {
154
+ return hash(root);
155
+ }
156
+ const hasProtocol = remote.includes("://");
157
+ remote = remote.replace(/^[a-z+]+:\/\//, "").replace(/^[^@/]+@/, "");
158
+ if (!hasProtocol) {
159
+ remote = remote.replace(":", "/");
160
+ }
161
+ remote = remote.replace(/\.git$/, "").replace(/\/+$/, "");
162
+ return hash(remote);
163
+ }
164
+ function hash(value) {
165
+ return createHash("sha256").update(`chromatic-vitest-telemetry-v1:${value}`).digest("hex");
166
+ }
167
+ function getChromaticVersion(root) {
168
+ try {
169
+ const require2 = createRequire2(join(root, "package.json"));
170
+ return require2("chromatic/package.json").version || "unknown";
171
+ } catch {
172
+ return "unknown";
173
+ }
174
+ }
175
+ async function writeTelemetryMetadata(outputDirectory, data) {
176
+ await writeFile(
177
+ resolve3(outputDirectory, TELEMETRY_METADATA_FILE),
178
+ JSON.stringify(data, null, 2),
179
+ "utf8"
180
+ );
181
+ }
182
+ async function readTelemetryMetadata(outputDirectory) {
183
+ const defaults = {
184
+ sessionId: "unknown",
185
+ projectId: "unknown",
186
+ chromaticVersion: "unknown",
187
+ vitestVersion: "unknown",
188
+ isVitestProjects: false
189
+ };
190
+ try {
191
+ const filename = resolve3(outputDirectory, TELEMETRY_METADATA_FILE);
192
+ if (!existsSync2(filename)) {
193
+ return defaults;
194
+ }
195
+ const content = await readFile(filename, "utf8");
196
+ const json = JSON.parse(content);
197
+ return { ...defaults, ...json };
198
+ } catch {
199
+ return defaults;
200
+ }
201
+ }
202
+
203
+ // src/node/telemetry/sanitize.ts
204
+ import { sep } from "node:path";
205
+ import { homedir } from "node:os";
206
+ function sanitizeError(error) {
207
+ if (error instanceof Error && error.stack) {
208
+ const raw = error.stack.includes(error.message) ? error.stack : `${error.message}
209
+ Stack: ${error.stack}`;
210
+ return sanitizeString(raw).slice(0, 2e3);
211
+ }
212
+ return sanitizeString(error instanceof Error ? error.message : String(error)).slice(0, 1e3);
213
+ }
214
+ function sanitizeString(value) {
215
+ return value.replaceAll(sep, "/").replace(toPathRegExp(process.cwd()), "<process-cwd>").replace(toPathRegExp(homedir()), "<homedir>");
216
+ }
217
+ function toPathRegExp(path3) {
218
+ const normalized = path3.replaceAll(sep, "/");
219
+ const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
220
+ return new RegExp(escaped, "gi");
221
+ }
222
+
223
+ // src/node/telemetry/session.ts
224
+ import { randomUUID } from "node:crypto";
225
+ var session = {
226
+ id: randomUUID(),
227
+ projectId: void 0,
228
+ chromaticVersion: void 0,
229
+ /**
230
+ * Directories used by `telemetry.logToFile`.
231
+ * Held in session to avoid race conditions when Vitest projects are used.
232
+ * Multiple projects could try to clean up the same directory while other one is writing there already.
233
+ */
234
+ cleanedLogFileDirectories: /* @__PURE__ */ new Set(),
235
+ /** Promises to wait before Vitest exists */
236
+ cleanups: /* @__PURE__ */ new Set(),
237
+ /** Whether cleanup hooks were already registered for this session */
238
+ cleanupRegistered: false,
239
+ /** Whether internal `.vitest/chromatic/telemetry-metadata.json` has been written */
240
+ isMetadataWritten: false,
241
+ /** Contents of `.vitest/chromatic/telemetry-metadata.json` */
242
+ telemetryMetadata: void 0
243
+ };
244
+
245
+ // src/node/telemetry/track.ts
246
+ async function trackCliEvent(event, options) {
247
+ const telemetry = resolveTelemetryOptions();
248
+ if (!telemetry.enabled) {
249
+ return;
250
+ }
251
+ let telemetryMetadata = session.telemetryMetadata;
252
+ if (session.telemetryMetadata === void 0) {
253
+ telemetryMetadata = await readTelemetryMetadata(options.outputDirectory);
254
+ session.telemetryMetadata = telemetryMetadata;
255
+ if (!("disabled" in telemetryMetadata)) {
256
+ session.id = telemetryMetadata.sessionId;
257
+ session.projectId = telemetryMetadata.projectId;
258
+ session.chromaticVersion = telemetryMetadata.chromaticVersion;
259
+ }
260
+ }
261
+ await _trackEvent(
262
+ event,
263
+ {
264
+ version: telemetryMetadata.vitestVersion,
265
+ config: { root: options.outputDirectory },
266
+ projects: telemetryMetadata.isVitestProjects ? [1, 2] : []
267
+ },
268
+ {
269
+ outputDirectory: options.outputDirectory,
270
+ telemetry
271
+ }
272
+ );
273
+ }
274
+ async function _trackEvent(event, vitest, options) {
275
+ const url = getEnv("CHROMATIC_TELEMETRY_URL") || TELEMETRY_URL;
276
+ const root = vitest.config.root;
277
+ const timestamp = (/* @__PURE__ */ new Date()).toISOString();
278
+ const outputDirectory = resolve4(root, options.outputDirectory);
279
+ session.projectId ||= await createProjectId(root);
280
+ session.chromaticVersion ||= getChromaticVersion(root);
281
+ const wireEvent = {
282
+ id: randomUUID2(),
283
+ sessionId: session.id,
284
+ projectId: session.projectId,
285
+ timestamp,
286
+ eventType: `${EVENT_TYPE_PREFIX}${event.eventType}`,
287
+ level: event.level,
288
+ payload: event.payload,
289
+ metadata: {
290
+ isCI,
291
+ pluginVersion: version,
292
+ nodeVersion: nodeVersion || "unknown",
293
+ vitestVersion: vitest.version,
294
+ isVitestProjects: vitest.projects.length > 1,
295
+ packageManager: packageManager.name,
296
+ packageManagerVersion: packageManager.version,
297
+ chromaticVersion: session.chromaticVersion
298
+ }
299
+ };
300
+ if (wireEvent.level === "error" && "error" in wireEvent.payload) {
301
+ wireEvent.payload.error = sanitizeError(wireEvent.payload.error);
302
+ }
303
+ let error = void 0;
304
+ try {
305
+ await fetch(`${url}/telemetry/v1/vitest/events`, {
306
+ method: "POST",
307
+ headers: { "Content-Type": "application/json" },
308
+ body: JSON.stringify(wireEvent),
309
+ signal: AbortSignal.timeout(TELEMETRY_FETCH_TIMEOUT_MS)
310
+ });
311
+ } catch (err) {
312
+ error = err instanceof Error ? err.message : String(err);
313
+ }
314
+ if (options.telemetry.logToFile) {
315
+ const logFile = resolve4(outputDirectory, TELEMETRY_LOG_FILE);
316
+ await mkdir(outputDirectory, { recursive: true });
317
+ await appendFile(logFile, `${JSON.stringify(wireEvent)}
318
+ `, "utf8");
319
+ if (error) {
320
+ await appendFile(logFile, `${JSON.stringify({ telemetryPostError: error })}
321
+ `, "utf8");
322
+ }
323
+ }
324
+ if (!session.isMetadataWritten) {
325
+ session.isMetadataWritten = true;
326
+ await writeTelemetryMetadata(outputDirectory, {
327
+ ...wireEvent.metadata,
328
+ sessionId: wireEvent.sessionId,
329
+ projectId: wireEvent.projectId
330
+ });
331
+ }
332
+ }
333
+
59
334
  // src/bin/archive-storybook.ts
60
335
  var args = process.argv.slice(2);
61
336
  var configDir = path2.resolve(import.meta.dirname, "../storybook-config");
337
+ var queue = Promise.resolve();
62
338
  try {
63
- archiveStorybook(args, configDir, DEFAULT_OUTPUT_DIR);
339
+ trackEvent2({ eventType: "storybook_dev_started", level: "info", payload: {} });
340
+ await archiveStorybook(args, configDir, DEFAULT_OUTPUT_DIR, { onArchivesCheck });
64
341
  } catch (err) {
342
+ trackEvent2({ eventType: "storybook_dev_failed", level: "error", payload: { error: err } });
65
343
  console.error(err.message);
66
344
  process.exitCode = 1;
67
345
  }
346
+ await queue;
347
+ function trackEvent2(event) {
348
+ queue = queue.then(
349
+ () => trackCliEvent(event, { outputDirectory: path2.dirname(archivesDir(DEFAULT_OUTPUT_DIR)) }).catch(
350
+ () => {
351
+ }
352
+ // Ignore telemetry errors
353
+ )
354
+ );
355
+ }
356
+ function onArchivesCheck(error) {
357
+ trackEvent2({
358
+ eventType: "archives_resolved",
359
+ level: error ? "error" : "info",
360
+ payload: {
361
+ success: error == void 0,
362
+ error,
363
+ isCustomLocation: process.env.CHROMATIC_ARCHIVE_LOCATION != void 0,
364
+ command: "archiveStorybook",
365
+ chromaticProjectId: void 0
366
+ }
367
+ });
368
+ }