@depup/expo__cli 55.0.16-depup.0

package/build/src/utils/tar.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    extractAsync: function() {
+        return extractAsync;
+    },
+    extractStream: function() {
+        return extractStream;
+    }
+});
+function _multitars() {
+    const data = require("multitars");
+    _multitars = function() {
+        return data;
+    };
+    return data;
+}
+function _nodecrypto() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:crypto"));
+    _nodecrypto = function() {
+        return data;
+    };
+    return data;
+}
+function _nodefs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+    _nodefs = function() {
+        return data;
+    };
+    return data;
+}
+function _nodepath() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:path"));
+    _nodepath = function() {
+        return data;
+    };
+    return data;
+}
+function _nodestream() {
+    const data = require("node:stream");
+    _nodestream = function() {
+        return data;
+    };
+    return data;
+}
+const _dir = require("./dir");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:utils:tar');
+class ChecksumStream extends TransformStream {
+    constructor(algorithm){
+        super({
+            transform: (chunk, controller)=>{
+                this.hash.update(chunk);
+                controller.enqueue(chunk);
+            }
+        });
+        this.hash = _nodecrypto().default.createHash(algorithm);
+    }
+    digest(encoding) {
+        return this.hash.digest(encoding);
+    }
+}
+async function extractStream(input, output, options = {}) {
+    output = _nodepath().default.resolve(output);
+    await (0, _dir.ensureDirectoryAsync)(output);
+    const { checksumAlgorithm, strip = 0, rename, filter } = options;
+    const checksumStream = new ChecksumStream(checksumAlgorithm || 'md5');
+    const decompressionStream = new DecompressionStream('gzip');
+    const body = input.pipeThrough(checksumStream).pipeThrough(decompressionStream);
+    for await (const file of (0, _multitars().untar)(body)){
+        let name = _nodepath().default.normalize(file.name);
+        if (filter && !filter(name, file.typeflag)) {
+            debug(`filtered: ${_nodepath().default.resolve(output, name)}`);
+            continue;
+        } else if (rename) {
+            name = rename(name, file.typeflag) ?? name;
+        }
+        for(let idx = 0; idx < strip; idx++){
+            const sepIdx = name.indexOf(_nodepath().default.sep);
+            if (sepIdx > -1) {
+                name = name.slice(sepIdx + 1);
+            } else {
+                break;
+            }
+        }
+        const resolved = _nodepath().default.resolve(output, name);
+        if (!resolved.startsWith(output)) {
+            debug(`skip: ${resolved}`);
+            continue;
+        }
+        const parent = _nodepath().default.dirname(resolved);
+        if (parent !== output) {
+            let exists = false;
+            try {
+                const stat = await _nodefs().default.promises.lstat(parent);
+                if (stat.isSymbolicLink() || !stat.isDirectory() && !stat.isFile()) {
+                    debug(`skip: ${resolved}`);
+                    continue;
+                } else if (stat.isDirectory()) {
+                    exists = true;
+                }
+            } catch  {}
+            if (!exists) {
+                debug(`mkdir(p): ${parent}`);
+                await _nodefs().default.promises.mkdir(parent, {
+                    recursive: true
+                });
+            }
+        }
+        switch(file.typeflag){
+            case _multitars().TarTypeFlag.FILE:
+                debug(`write(${file.mode.toString(8)}): ${resolved}`);
+                await _nodefs().default.promises.writeFile(resolved, (0, _multitars().streamToAsyncIterable)(file.stream()), {
+                    mode: file.mode
+                });
+                break;
+            case _multitars().TarTypeFlag.DIRECTORY:
+                debug(`mkdir(${file.mode.toString(8)}): ${resolved}`);
+                try {
+                    await _nodefs().default.promises.mkdir(resolved, {
+                        mode: file.mode
+                    });
+                } catch (error) {
+                    if (error.code !== 'EEXIST') {
+                        throw error;
+                    }
+                }
+                break;
+            case _multitars().TarTypeFlag.SYMLINK:
+            case _multitars().TarTypeFlag.LINK:
+                {
+                    const target = _nodepath().default.resolve(parent, file.linkname ?? '');
+                    if (!target.startsWith(output) || target === parent) {
+                        debug(`skip: ${resolved} -> ${target}`);
+                        continue;
+                    }
+                    if (file.typeflag === _multitars().TarTypeFlag.LINK) {
+                        debug(`link: ${resolved} -> ${target}`);
+                        await _nodefs().default.promises.link(target, resolved);
+                    } else {
+                        const stat = await _nodefs().default.promises.lstat(target).catch(()=>null);
+                        const type = (stat == null ? void 0 : stat.isDirectory()) ? 'dir' : 'file';
+                        debug(`symlink(${type}): ${resolved} -> ${target}`);
+                        await _nodefs().default.promises.symlink(target, resolved, type);
+                    }
+                    break;
+                }
+        }
+    }
+    return checksumStream.digest('hex');
+}
+async function extractAsync(input, output, options) {
+    await extractStream(_nodestream().Readable.toWeb(_nodefs().default.createReadStream(input)), output, options);
+}
+
+//# sourceMappingURL=tar.js.map

package/build/src/utils/tar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/tar.ts"],"sourcesContent":["import { streamToAsyncIterable, TarTypeFlag, untar } from 'multitars';\nimport crypto from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { Readable } from 'node:stream';\n\nimport { ensureDirectoryAsync } from './dir';\n\nconst debug = require('debug')('expo:utils:tar') as typeof console.log;\n\nclass ChecksumStream extends TransformStream {\n  hash: crypto.Hash;\n  constructor(algorithm: string) {\n    super({\n      transform: (chunk, controller) => {\n        this.hash.update(chunk);\n        controller.enqueue(chunk);\n      },\n    });\n    this.hash = crypto.createHash(algorithm);\n  }\n\n  digest(): Buffer;\n  digest(encoding: crypto.BinaryToTextEncoding): string;\n  digest(encoding?: crypto.BinaryToTextEncoding): string | Buffer {\n    return this.hash.digest(encoding!);\n  }\n}\n\nexport interface ExtractOptions {\n  strip?: number;\n  filter?(name: string, type: TarTypeFlag): boolean | null | undefined;\n  rename?(name: string, type: TarTypeFlag): string | null | undefined;\n  checksumAlgorithm?: string;\n}\n\nexport async function extractStream(\n  input: ReadableStream,\n  output: string,\n  options: ExtractOptions = {}\n): Promise<string> {\n  output = path.resolve(output);\n  await ensureDirectoryAsync(output);\n\n  const { checksumAlgorithm, strip = 0, rename, filter } = options;\n\n  const checksumStream = new ChecksumStream(checksumAlgorithm || 'md5');\n  const decompressionStream = new DecompressionStream('gzip');\n\n  const body = input.pipeThrough(checksumStream).pipeThrough(decompressionStream);\n\n  for await (const file of untar(body)) {\n    let name = path.normalize(file.name);\n    if (filter && !filter(name, file.typeflag)) {\n      debug(`filtered: ${path.resolve(output, name)}`);\n      continue;\n    } else if (rename) {\n      name = rename(name, file.typeflag) ?? name;\n    }\n\n    for (let idx = 0; idx < strip; idx++) {\n      const sepIdx = name.indexOf(path.sep);\n      if (sepIdx > -1) {\n        name = name.slice(sepIdx + 1);\n      } else {\n        break;\n      }\n    }\n\n    const resolved = path.resolve(output, name);\n    if (!resolved.startsWith(output)) {\n      debug(`skip: ${resolved}`);\n      continue;\n    }\n\n    const parent = path.dirname(resolved);\n    if (parent !== output) {\n      let exists = false;\n      try {\n        const stat = await fs.promises.lstat(parent);\n        if (stat.isSymbolicLink() || (!stat.isDirectory() && !stat.isFile())) {\n          debug(`skip: ${resolved}`);\n          continue;\n        } else if (stat.isDirectory()) {\n          exists = true;\n        }\n      } catch {}\n\n      if (!exists) {\n        debug(`mkdir(p): ${parent}`);\n        await fs.promises.mkdir(parent, { recursive: true });\n      }\n    }\n\n    switch (file.typeflag) {\n      case TarTypeFlag.FILE:\n        debug(`write(${file.mode.toString(8)}): ${resolved}`);\n        await fs.promises.writeFile(resolved, streamToAsyncIterable(file.stream()), {\n          mode: file.mode,\n        });\n        break;\n      case TarTypeFlag.DIRECTORY:\n        debug(`mkdir(${file.mode.toString(8)}): ${resolved}`);\n        try {\n          await fs.promises.mkdir(resolved, { mode: file.mode });\n        } catch (error: any) {\n          if (error.code !== 'EEXIST') {\n            throw error;\n          }\n        }\n        break;\n      case TarTypeFlag.SYMLINK:\n      case TarTypeFlag.LINK: {\n        const target = path.resolve(parent, file.linkname ?? '');\n        if (!target.startsWith(output) || target === parent) {\n          debug(`skip: ${resolved} -> ${target}`);\n          continue;\n        }\n\n        if (file.typeflag === TarTypeFlag.LINK) {\n          debug(`link: ${resolved} -> ${target}`);\n          await fs.promises.link(target, resolved);\n        } else {\n          const stat = await fs.promises.lstat(target).catch(() => null);\n          const type = stat?.isDirectory() ? 'dir' : 'file';\n          debug(`symlink(${type}): ${resolved} -> ${target}`);\n          await fs.promises.symlink(target, resolved, type);\n        }\n        break;\n      }\n    }\n  }\n\n  return checksumStream.digest('hex');\n}\n\n/** Extract a tar using built-in tools if available and falling back on Node.js. */\nexport async function extractAsync(\n  input: string,\n  output: string,\n  options?: ExtractOptions\n): Promise<void> {\n  await extractStream(\n    Readable.toWeb(fs.createReadStream(input)) as ReadableStream,\n    output,\n    options\n  );\n}\n"],"names":["extractAsync","extractStream","debug","require","ChecksumStream","TransformStream","constructor","algorithm","transform","chunk","controller","hash","update","enqueue","crypto","createHash","digest","encoding","input","output","options","path","resolve","ensureDirectoryAsync","checksumAlgorithm","strip","rename","filter","checksumStream","decompressionStream","DecompressionStream","body","pipeThrough","file","untar","name","normalize","typeflag","idx","sepIdx","indexOf","sep","slice","resolved","startsWith","parent","dirname","exists","stat","fs","promises","lstat","isSymbolicLink","isDirectory","isFile","mkdir","recursive","TarTypeFlag","FILE","mode","toString","writeFile","streamToAsyncIterable","stream","DIRECTORY","error","code","SYMLINK","LINK","target","linkname","link","catch","type","symlink","Readable","toWeb","createReadStream"],"mappings":"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"}

package/build/src/utils/telemetry/Telemetry.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Telemetry", {
+    enumerable: true,
+    get: function() {
+        return Telemetry;
+    }
+});
+function _nodecrypto() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:crypto"));
+    _nodecrypto = function() {
+        return data;
+    };
+    return data;
+}
+const _FetchClient = require("./clients/FetchClient");
+const _FetchDetachedClient = require("./clients/FetchDetachedClient");
+const _context = require("./utils/context");
+const _UserSettings = require("../../api/user/UserSettings");
+const _env = require("../env");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:telemetry');
+class Telemetry {
+    constructor({ anonymousId = (0, _UserSettings.getAnonymousId)(), sessionId = _nodecrypto().default.randomUUID(), userId, strategy = 'detached' } = {}){
+        this.context = (0, _context.createContext)();
+        this.client = new _FetchDetachedClient.FetchDetachedClient();
+        /** A list of all events, recorded before the telemetry was fully initialized */ this.earlyRecords = [];
+        this.actor = {
+            anonymousId,
+            sessionId
+        };
+        this.setStrategy(_env.env.EXPO_NO_TELEMETRY_DETACH ? 'debug' : strategy);
+        if (userId) {
+            this.initialize({
+                userId
+            });
+        }
+    }
+    get strategy() {
+        return this.client.strategy;
+    }
+    setStrategy(strategy) {
+        // Abort when client is already using the correct strategy
+        if (this.client.strategy === strategy) return;
+        // Abort when debugging the telemetry
+        if (_env.env.EXPO_NO_TELEMETRY_DETACH && strategy !== 'debug') return;
+        debug('Switching strategy from %s to %s', this.client.strategy, strategy);
+        // Load and instantiate the correct client, based on strategy
+        const client = createClientFromStrategy(strategy);
+        // Replace the client, and re-record any pending records
+        this.client.abort().forEach((record)=>client.record([
+                record
+            ]));
+        this.client = client;
+        return this;
+    }
+    get isInitialized() {
+        return this.actor.userHash !== undefined;
+    }
+    initialize({ userId }) {
+        this.actor.userHash = userId ? hashUserId(userId) : null;
+        this.flushEarlyRecords();
+    }
+    flushEarlyRecords() {
+        if (this.earlyRecords.length) {
+            this.recordInternal(this.earlyRecords);
+            this.earlyRecords = [];
+        }
+    }
+    recordInternal(records) {
+        return this.client.record(records.map((record)=>({
+                ...record,
+                type: 'track',
+                sentAt: new Date(),
+                messageId: createMessageId(record),
+                anonymousId: this.actor.anonymousId,
+                userHash: this.actor.userHash,
+                context: {
+                    ...this.context,
+                    sessionId: this.actor.sessionId,
+                    client: {
+                        mode: this.client.strategy
+                    }
+                }
+            })));
+    }
+    record(record) {
+        const records = Array.isArray(record) ? record : [
+            record
+        ];
+        debug('Recording %d event(s)', records.length);
+        if (!this.isInitialized) {
+            this.earlyRecords.push(...records);
+            return;
+        }
+        return this.recordInternal(records);
+    }
+    flush() {
+        debug('Flushing events...');
+        this.flushEarlyRecords();
+        return this.client.flush();
+    }
+    flushOnExit() {
+        this.setStrategy('detached');
+        this.flushEarlyRecords();
+        return this.client.flush();
+    }
+}
+function createClientFromStrategy(strategy) {
+    // When debugging, use the actual Rudderstack client, but lazy load it
+    if (_env.env.EXPO_NO_TELEMETRY_DETACH || strategy === 'debug' || strategy === 'instant') {
+        return new _FetchClient.FetchClient();
+    }
+    return new _FetchDetachedClient.FetchDetachedClient();
+}
+/** Generate a unique message ID using a random hash and UUID */ function createMessageId(record) {
+    const uuid = _nodecrypto().default.randomUUID();
+    const md5 = _nodecrypto().default.createHash('md5').update(JSON.stringify(record)).digest('hex');
+    return `node-${md5}-${uuid}`;
+}
+/** Hash the user identifier to make it untracable */ function hashUserId(userId) {
+    return _nodecrypto().default.createHash('sha256').update(userId).digest('hex');
+}
+
+//# sourceMappingURL=Telemetry.js.map

package/build/src/utils/telemetry/Telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/telemetry/Telemetry.ts"],"sourcesContent":["import crypto from 'node:crypto';\n\nimport { FetchClient } from './clients/FetchClient';\nimport { FetchDetachedClient } from './clients/FetchDetachedClient';\nimport { TelemetryClient, TelemetryClientStrategy, TelemetryRecord } from './types';\nimport { createContext } from './utils/context';\nimport { getAnonymousId } from '../../api/user/UserSettings';\nimport { env } from '../env';\n\nconst debug = require('debug')('expo:telemetry') as typeof console.log;\n\ntype TelemetryOptions = {\n  /** A locally generated ID, untracable to an actual user */\n  anonymousId?: string;\n  /** A locally generated ID, per CLI invocation */\n  sessionId?: string;\n  /** The authenticated user ID, this is used to generate an untracable hash */\n  userId?: string;\n  /** The underlying telemetry strategy to use */\n  strategy?: TelemetryClientStrategy;\n};\n\ntype TelemetryActor = Required<Pick<TelemetryOptions, 'anonymousId' | 'sessionId'>> & {\n  /**\n   * Hashed version of the user ID, untracable to an actual user.\n   * If this value is set to `undefined`, telemetry is considered uninitialized and will wait until its set.\n   * If this value is set to `null`, telemetry is considered initialized without an authenticated user.\n   * If this value is set to a string, telemetry is considered initialized with an authenticated user.\n   */\n  userHash?: string | null;\n};\n\nexport class Telemetry {\n  private context = createContext();\n  private client: TelemetryClient = new FetchDetachedClient();\n  private actor: TelemetryActor;\n\n  /** A list of all events, recorded before the telemetry was fully initialized */\n  private earlyRecords: TelemetryRecord[] = [];\n\n  constructor({\n    anonymousId = getAnonymousId(),\n    sessionId = crypto.randomUUID(),\n    userId,\n    strategy = 'detached',\n  }: TelemetryOptions = {}) {\n    this.actor = { anonymousId, sessionId };\n    this.setStrategy(env.EXPO_NO_TELEMETRY_DETACH ? 'debug' : strategy);\n\n    if (userId) {\n      this.initialize({ userId });\n    }\n  }\n\n  get strategy() {\n    return this.client.strategy;\n  }\n\n  setStrategy(strategy: TelemetryOptions['strategy']) {\n    // Abort when client is already using the correct strategy\n    if (this.client.strategy === strategy) return;\n    // Abort when debugging the telemetry\n    if (env.EXPO_NO_TELEMETRY_DETACH && strategy !== 'debug') return;\n\n    debug('Switching strategy from %s to %s', this.client.strategy, strategy);\n\n    // Load and instantiate the correct client, based on strategy\n    const client = createClientFromStrategy(strategy);\n    // Replace the client, and re-record any pending records\n    this.client.abort().forEach((record) => client.record([record]));\n    this.client = client;\n\n    return this;\n  }\n\n  get isInitialized() {\n    return this.actor.userHash !== undefined;\n  }\n\n  initialize({ userId }: { userId: string | null }) {\n    this.actor.userHash = userId ? hashUserId(userId) : null;\n    this.flushEarlyRecords();\n  }\n\n  private flushEarlyRecords() {\n    if (this.earlyRecords.length) {\n      this.recordInternal(this.earlyRecords);\n      this.earlyRecords = [];\n    }\n  }\n\n  private recordInternal(records: TelemetryRecord[]) {\n    return this.client.record(\n      records.map((record) => ({\n        ...record,\n        type: 'track' as const,\n        sentAt: new Date(),\n        messageId: createMessageId(record),\n        anonymousId: this.actor.anonymousId,\n        userHash: this.actor.userHash,\n        context: {\n          ...this.context,\n          sessionId: this.actor.sessionId,\n          client: { mode: this.client.strategy },\n        },\n      }))\n    );\n  }\n\n  record(record: TelemetryRecord | TelemetryRecord[]) {\n    const records = Array.isArray(record) ? record : [record];\n\n    debug('Recording %d event(s)', records.length);\n\n    if (!this.isInitialized) {\n      this.earlyRecords.push(...records);\n      return;\n    }\n\n    return this.recordInternal(records);\n  }\n\n  flush() {\n    debug('Flushing events...');\n    this.flushEarlyRecords();\n    return this.client.flush();\n  }\n\n  flushOnExit() {\n    this.setStrategy('detached');\n    this.flushEarlyRecords();\n    return this.client.flush();\n  }\n}\n\nfunction createClientFromStrategy(strategy: TelemetryOptions['strategy']) {\n  // When debugging, use the actual Rudderstack client, but lazy load it\n  if (env.EXPO_NO_TELEMETRY_DETACH || strategy === 'debug' || strategy === 'instant') {\n    return new FetchClient();\n  }\n\n  return new FetchDetachedClient();\n}\n\n/** Generate a unique message ID using a random hash and UUID */\nfunction createMessageId(record: TelemetryRecord) {\n  const uuid = crypto.randomUUID();\n  const md5 = crypto.createHash('md5').update(JSON.stringify(record)).digest('hex');\n\n  return `node-${md5}-${uuid}`;\n}\n\n/** Hash the user identifier to make it untracable */\nfunction hashUserId(userId: string) {\n  return crypto.createHash('sha256').update(userId).digest('hex');\n}\n"],"names":["Telemetry","debug","require","constructor","anonymousId","getAnonymousId","sessionId","crypto","randomUUID","userId","strategy","context","createContext","client","FetchDetachedClient","earlyRecords","actor","setStrategy","env","EXPO_NO_TELEMETRY_DETACH","initialize","createClientFromStrategy","abort","forEach","record","isInitialized","userHash","undefined","hashUserId","flushEarlyRecords","length","recordInternal","records","map","type","sentAt","Date","messageId","createMessageId","mode","Array","isArray","push","flush","flushOnExit","FetchClient","uuid","md5","createHash","update","JSON","stringify","digest"],"mappings":"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"}

package/build/src/utils/telemetry/clients/FetchClient.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FetchClient", {
+    enumerable: true,
+    get: function() {
+        return FetchClient;
+    }
+});
+function _nodebuffer() {
+    const data = require("node:buffer");
+    _nodebuffer = function() {
+        return data;
+    };
+    return data;
+}
+const _fetch = require("../../fetch");
+const _constants = require("../utils/constants");
+class FetchClient {
+    constructor({ fetch = createTelemetryFetch(), url = _constants.TELEMETRY_ENDPOINT, target = _constants.TELEMETRY_TARGET } = {}){
+        /** This client should be used for long-running commands */ this.strategy = 'instant';
+        /** All records that are queued and being sent */ this.entries = new Set();
+        this.fetch = fetch;
+        this.url = url;
+        this.headers = {
+            accept: 'application/json',
+            'content-type': 'application/json',
+            'user-agent': `expo-cli/${"55.0.16"}`,
+            authorization: 'Basic ' + _nodebuffer().Buffer.from(`${target}:`).toString('base64')
+        };
+    }
+    queue(records, controller, request) {
+        const entry = mutePromise(request);
+        entry.finally(()=>this.entries.delete(entry));
+        entry.controller = controller;
+        entry.records = records;
+        this.entries.add(entry);
+        return entry;
+    }
+    record(record) {
+        const records = Array.isArray(record) ? record : [
+            record
+        ];
+        if (!records.length) return;
+        const controller = new AbortController();
+        const body = JSON.stringify({
+            sentAt: new Date(),
+            batch: records
+        });
+        return this.queue(records, controller, this.fetch(this.url, {
+            body,
+            method: 'POST',
+            signal: controller.signal,
+            headers: this.headers
+        }));
+    }
+    flush() {
+        return mutePromise(Promise.all(this.entries));
+    }
+    abort() {
+        const records = [];
+        this.entries.forEach((entry)=>{
+            try {
+                entry.controller.abort();
+                records.push(...entry.records);
+            } catch  {
+            // Ignore abort errors
+            }
+        });
+        return records;
+    }
+}
+function createTelemetryFetch() {
+    return async function telemetryFetch(info, init) {
+        let error;
+        for(let attemptCount = 0; attemptCount < 3; attemptCount++){
+            try {
+                return await (0, _fetch.fetch)(info, init);
+            } catch (_error) {
+                error = _error;
+            }
+        }
+        throw error;
+    };
+}
+/** Mute a promise by removing the original return type and hide errors */ function mutePromise(promise) {
+    return promise.then(()=>{}, ()=>{});
+}
+
+//# sourceMappingURL=FetchClient.js.map

package/build/src/utils/telemetry/clients/FetchClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/utils/telemetry/clients/FetchClient.ts"],"sourcesContent":["import type { RequestInit } from 'fetch-nodeshim';\nimport { Buffer } from 'node:buffer';\n\nimport { fetch } from '../../fetch';\nimport { TelemetryClient, TelemetryClientStrategy, TelemetryRecordInternal } from '../types';\nimport { TELEMETRY_ENDPOINT, TELEMETRY_TARGET } from '../utils/constants';\n\ntype Fetch = typeof fetch;\n\ntype FetchClientOptions = {\n  /** The fetch method for sending events, should handle retries and timeouts */\n  fetch?: Fetch;\n  /** The endpoint for recorded events */\n  url?: string;\n  /** The telemetry target for all events */\n  target?: string;\n};\n\ntype FetchClientEntry = Promise<void> & {\n  records: TelemetryRecordInternal[];\n  controller: AbortController;\n};\n\nexport class FetchClient implements TelemetryClient {\n  /** This client should be used for long-running commands */\n  readonly strategy: TelemetryClientStrategy = 'instant';\n  /** The fetch instance used to transport telemetry to the backend */\n  private fetch: Fetch;\n  /** The endpoint to send events to */\n  private url: string;\n  /** Additional headers to send with every event */\n  private headers: RequestInit['headers'];\n  /** All records that are queued and being sent */\n  private entries: Set<FetchClientEntry> = new Set();\n\n  constructor({\n    fetch = createTelemetryFetch(),\n    url = TELEMETRY_ENDPOINT,\n    target = TELEMETRY_TARGET,\n  }: FetchClientOptions = {}) {\n    this.fetch = fetch;\n    this.url = url;\n    this.headers = {\n      accept: 'application/json',\n      'content-type': 'application/json',\n      'user-agent': `expo-cli/${process.env.__EXPO_VERSION}`,\n      authorization: 'Basic ' + Buffer.from(`${target}:`).toString('base64'),\n    };\n  }\n\n  private queue(\n    records: TelemetryRecordInternal[],\n    controller: AbortController,\n    request: ReturnType<typeof fetch>\n  ) {\n    const entry: FetchClientEntry = mutePromise(request) as any;\n    entry.finally(() => this.entries.delete(entry));\n    entry.controller = controller;\n    entry.records = records;\n\n    this.entries.add(entry);\n\n    return entry;\n  }\n\n  record(record: TelemetryRecordInternal[]) {\n    const records = Array.isArray(record) ? record : [record];\n\n    if (!records.length) return;\n\n    const controller = new AbortController();\n    const body = JSON.stringify({\n      sentAt: new Date(),\n      batch: records,\n    });\n\n    return this.queue(\n      records,\n      controller,\n      this.fetch(this.url, {\n        body,\n        method: 'POST',\n        signal: controller.signal,\n        headers: this.headers,\n      })\n    );\n  }\n\n  flush() {\n    return mutePromise(Promise.all(this.entries));\n  }\n\n  abort() {\n    const records: TelemetryRecordInternal[] = [];\n\n    this.entries.forEach((entry) => {\n      try {\n        entry.controller.abort();\n        records.push(...entry.records);\n      } catch {\n        // Ignore abort errors\n      }\n    });\n\n    return records;\n  }\n}\n\nfunction createTelemetryFetch(): typeof fetch {\n  return async function telemetryFetch(info, init) {\n    let error: any;\n    for (let attemptCount = 0; attemptCount < 3; attemptCount++) {\n      try {\n        return await fetch(info, init);\n      } catch (_error: any) {\n        error = _error;\n      }\n    }\n    throw error;\n  };\n}\n\n/** Mute a promise by removing the original return type and hide errors */\nfunction mutePromise(promise: Promise<any>) {\n  return promise.then(\n    () => {},\n    () => {}\n  );\n}\n"],"names":["FetchClient","constructor","fetch","createTelemetryFetch","url","TELEMETRY_ENDPOINT","target","TELEMETRY_TARGET","strategy","entries","Set","headers","accept","process","env","__EXPO_VERSION","authorization","Buffer","from","toString","queue","records","controller","request","entry","mutePromise","finally","delete","add","record","Array","isArray","length","AbortController","body","JSON","stringify","sentAt","Date","batch","method","signal","flush","Promise","all","abort","forEach","push","telemetryFetch","info","init","error","attemptCount","_error","promise","then"],"mappings":";;;;+BAuBaA;;;eAAAA;;;;yBAtBU;;;;;;uBAED;2BAE+B;AAkB9C,MAAMA;IAYXC,YAAY,EACVC,QAAQC,sBAAsB,EAC9BC,MAAMC,6BAAkB,EACxBC,SAASC,2BAAgB,EACN,GAAG,CAAC,CAAC,CAAE;QAf5B,yDAAyD,QAChDC,WAAoC;QAO7C,+CAA+C,QACvCC,UAAiC,IAAIC;QAO3C,IAAI,CAACR,KAAK,GAAGA;QACb,IAAI,CAACE,GAAG,GAAGA;QACX,IAAI,CAACO,OAAO,GAAG;YACbC,QAAQ;YACR,gBAAgB;YAChB,cAAc,CAAC,SAAS,EAAEC,QAAQC,GAAG,CAACC,cAAc,EAAE;YACtDC,eAAe,WAAWC,oBAAM,CAACC,IAAI,CAAC,GAAGZ,OAAO,CAAC,CAAC,EAAEa,QAAQ,CAAC;QAC/D;IACF;IAEQC,MACNC,OAAkC,EAClCC,UAA2B,EAC3BC,OAAiC,EACjC;QACA,MAAMC,QAA0BC,YAAYF;QAC5CC,MAAME,OAAO,CAAC,IAAM,IAAI,CAACjB,OAAO,CAACkB,MAAM,CAACH;QACxCA,MAAMF,UAAU,GAAGA;QACnBE,MAAMH,OAAO,GAAGA;QAEhB,IAAI,CAACZ,OAAO,CAACmB,GAAG,CAACJ;QAEjB,OAAOA;IACT;IAEAK,OAAOA,MAAiC,EAAE;QACxC,MAAMR,UAAUS,MAAMC,OAAO,CAACF,UAAUA,SAAS;YAACA;SAAO;QAEzD,IAAI,CAACR,QAAQW,MAAM,EAAE;QAErB,MAAMV,aAAa,IAAIW;QACvB,MAAMC,OAAOC,KAAKC,SAAS,CAAC;YAC1BC,QAAQ,IAAIC;YACZC,OAAOlB;QACT;QAEA,OAAO,IAAI,CAACD,KAAK,CACfC,SACAC,YACA,IAAI,CAACpB,KAAK,CAAC,IAAI,CAACE,GAAG,EAAE;YACnB8B;YACAM,QAAQ;YACRC,QAAQnB,WAAWmB,MAAM;YACzB9B,SAAS,IAAI,CAACA,OAAO;QACvB;IAEJ;IAEA+B,QAAQ;QACN,OAAOjB,YAAYkB,QAAQC,GAAG,CAAC,IAAI,CAACnC,OAAO;IAC7C;IAEAoC,QAAQ;QACN,MAAMxB,UAAqC,EAAE;QAE7C,IAAI,CAACZ,OAAO,CAACqC,OAAO,CAAC,CAACtB;YACpB,IAAI;gBACFA,MAAMF,UAAU,CAACuB,KAAK;gBACtBxB,QAAQ0B,IAAI,IAAIvB,MAAMH,OAAO;YAC/B,EAAE,OAAM;YACN,sBAAsB;YACxB;QACF;QAEA,OAAOA;IACT;AACF;AAEA,SAASlB;IACP,OAAO,eAAe6C,eAAeC,IAAI,EAAEC,IAAI;QAC7C,IAAIC;QACJ,IAAK,IAAIC,eAAe,GAAGA,eAAe,GAAGA,eAAgB;YAC3D,IAAI;gBACF,OAAO,MAAMlD,IAAAA,YAAK,EAAC+C,MAAMC;YAC3B,EAAE,OAAOG,QAAa;gBACpBF,QAAQE;YACV;QACF;QACA,MAAMF;IACR;AACF;AAEA,wEAAwE,GACxE,SAAS1B,YAAY6B,OAAqB;IACxC,OAAOA,QAAQC,IAAI,CACjB,KAAO,GACP,KAAO;AAEX"}

package/build/src/utils/telemetry/clients/FetchDetachedClient.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FetchDetachedClient", {
+    enumerable: true,
+    get: function() {
+        return FetchDetachedClient;
+    }
+});
+function _nodechild_process() {
+    const data = require("node:child_process");
+    _nodechild_process = function() {
+        return data;
+    };
+    return data;
+}
+function _nodefs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+    _nodefs = function() {
+        return data;
+    };
+    return data;
+}
+function _nodepath() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:path"));
+    _nodepath = function() {
+        return data;
+    };
+    return data;
+}
+const _createTempPath = require("../../createTempPath");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:telemetry:client:detached');
+class FetchDetachedClient {
+    abort() {
+        return this.records;
+    }
+    record(record) {
+        this.records.push(...record.map((record)=>({
+                ...record,
+                originalTimestamp: record.sentAt
+            })));
+    }
+    async flush() {
+        try {
+            if (!this.records.length) {
+                return debug('No records to flush, skipping...');
+            }
+            const file = (0, _createTempPath.createTempFilePath)('expo-telemetry.json');
+            const data = JSON.stringify({
+                records: this.records
+            });
+            this.records = [];
+            await _nodefs().default.promises.mkdir(_nodepath().default.dirname(file), {
+                recursive: true
+            });
+            await _nodefs().default.promises.writeFile(file, data);
+            const child = (0, _nodechild_process().spawn)(process.execPath, [
+                require.resolve('./flushFetchDetached'),
+                file
+            ], {
+                detached: true,
+                windowsHide: true,
+                shell: false,
+                stdio: 'ignore'
+            });
+            child.unref();
+        } catch (error) {
+            // This could fail if any direct or indirect imports change during an upgrade to the `expo` dependency via `npx expo install --fix`,
+            // since this file may no longer be present after the upgrade, but before the process under the old Expo CLI version is terminated.
+            debug('Exception while initiating detached flush:', error);
+        }
+        debug('Detached flush started');
+    }
+    constructor(){
+        /** This client should be used for short-lived commands */ this.strategy = 'detached';
+        /** All recorded telemetry events */ this.records = [];
+    }
+}
+
+//# sourceMappingURL=FetchDetachedClient.js.map

package/build/src/utils/telemetry/clients/FetchDetachedClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/utils/telemetry/clients/FetchDetachedClient.ts"],"sourcesContent":["import { spawn } from 'node:child_process';\nimport fs from 'node:fs';\nimport path from 'node:path';\n\nimport { createTempFilePath } from '../../createTempPath';\nimport type { TelemetryClient, TelemetryClientStrategy, TelemetryRecordInternal } from '../types';\n\nconst debug = require('debug')('expo:telemetry:client:detached') as typeof console.log;\n\nexport class FetchDetachedClient implements TelemetryClient {\n  /** This client should be used for short-lived commands */\n  readonly strategy: TelemetryClientStrategy = 'detached';\n  /** All recorded telemetry events */\n  private records: TelemetryRecordInternal[] = [];\n\n  abort() {\n    return this.records;\n  }\n\n  record(record: TelemetryRecordInternal[]) {\n    this.records.push(\n      ...record.map((record) => ({\n        ...record,\n        originalTimestamp: record.sentAt,\n      }))\n    );\n  }\n\n  async flush() {\n    try {\n      if (!this.records.length) {\n        return debug('No records to flush, skipping...');\n      }\n\n      const file = createTempFilePath('expo-telemetry.json');\n      const data = JSON.stringify({ records: this.records });\n\n      this.records = [];\n\n      await fs.promises.mkdir(path.dirname(file), { recursive: true });\n      await fs.promises.writeFile(file, data);\n\n      const child = spawn(process.execPath, [require.resolve('./flushFetchDetached'), file], {\n        detached: true,\n        windowsHide: true,\n        shell: false,\n        stdio: 'ignore',\n      });\n\n      child.unref();\n    } catch (error) {\n      // This could fail if any direct or indirect imports change during an upgrade to the `expo` dependency via `npx expo install --fix`,\n      // since this file may no longer be present after the upgrade, but before the process under the old Expo CLI version is terminated.\n      debug('Exception while initiating detached flush:', error);\n    }\n\n    debug('Detached flush started');\n  }\n}\n"],"names":["FetchDetachedClient","debug","require","abort","records","record","push","map","originalTimestamp","sentAt","flush","length","file","createTempFilePath","data","JSON","stringify","fs","promises","mkdir","path","dirname","recursive","writeFile","child","spawn","process","execPath","resolve","detached","windowsHide","shell","stdio","unref","error","strategy"],"mappings":";;;;+BASaA;;;eAAAA;;;;yBATS;;;;;;;gEACP;;;;;;;gEACE;;;;;;gCAEkB;;;;;;AAGnC,MAAMC,QAAQC,QAAQ,SAAS;AAExB,MAAMF;IAMXG,QAAQ;QACN,OAAO,IAAI,CAACC,OAAO;IACrB;IAEAC,OAAOA,MAAiC,EAAE;QACxC,IAAI,CAACD,OAAO,CAACE,IAAI,IACZD,OAAOE,GAAG,CAAC,CAACF,SAAY,CAAA;gBACzB,GAAGA,MAAM;gBACTG,mBAAmBH,OAAOI,MAAM;YAClC,CAAA;IAEJ;IAEA,MAAMC,QAAQ;QACZ,IAAI;YACF,IAAI,CAAC,IAAI,CAACN,OAAO,CAACO,MAAM,EAAE;gBACxB,OAAOV,MAAM;YACf;YAEA,MAAMW,OAAOC,IAAAA,kCAAkB,EAAC;YAChC,MAAMC,OAAOC,KAAKC,SAAS,CAAC;gBAAEZ,SAAS,IAAI,CAACA,OAAO;YAAC;YAEpD,IAAI,CAACA,OAAO,GAAG,EAAE;YAEjB,MAAMa,iBAAE,CAACC,QAAQ,CAACC,KAAK,CAACC,mBAAI,CAACC,OAAO,CAACT,OAAO;gBAAEU,WAAW;YAAK;YAC9D,MAAML,iBAAE,CAACC,QAAQ,CAACK,SAAS,CAACX,MAAME;YAElC,MAAMU,QAAQC,IAAAA,0BAAK,EAACC,QAAQC,QAAQ,EAAE;gBAACzB,QAAQ0B,OAAO,CAAC;gBAAyBhB;aAAK,EAAE;gBACrFiB,UAAU;gBACVC,aAAa;gBACbC,OAAO;gBACPC,OAAO;YACT;YAEAR,MAAMS,KAAK;QACb,EAAE,OAAOC,OAAO;YACd,oIAAoI;YACpI,mIAAmI;YACnIjC,MAAM,8CAA8CiC;QACtD;QAEAjC,MAAM;IACR;;QA/CA,wDAAwD,QAC/CkC,WAAoC;QAC7C,kCAAkC,QAC1B/B,UAAqC,EAAE;;AA6CjD"}

package/build/src/utils/telemetry/clients/flushFetchDetached.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _nodefs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+    _nodefs = function() {
+        return data;
+    };
+    return data;
+}
+const _FetchClient = require("./FetchClient");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const telemetryFile = process.argv[2];
+flush().catch(()=>_nodefs().default.promises.unlink(telemetryFile)).finally(()=>process.exit(0));
+async function flush() {
+    if (!telemetryFile) return;
+    let json;
+    let data;
+    try {
+        json = await _nodefs().default.promises.readFile(telemetryFile, 'utf8');
+        data = JSON.parse(json);
+    } catch (error) {
+        if (error.code === 'ENOENT') return;
+        throw error;
+    }
+    if (data.records.length) {
+        const client = new _FetchClient.FetchClient();
+        await client.record(data.records);
+        await client.flush();
+    }
+    await _nodefs().default.promises.unlink(telemetryFile);
+}
+
+//# sourceMappingURL=flushFetchDetached.js.map

package/build/src/utils/telemetry/clients/flushFetchDetached.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/utils/telemetry/clients/flushFetchDetached.ts"],"sourcesContent":["import fs from 'node:fs';\n\nimport { FetchClient } from './FetchClient';\nimport type { TelemetryRecordInternal } from '../types';\n\nconst telemetryFile = process.argv[2];\n\nflush()\n  .catch(() => fs.promises.unlink(telemetryFile))\n  .finally(() => process.exit(0));\n\nasync function flush() {\n  if (!telemetryFile) return;\n\n  let json: string;\n  let data: { records: TelemetryRecordInternal[] };\n\n  try {\n    json = await fs.promises.readFile(telemetryFile, 'utf8');\n    data = JSON.parse(json) as any;\n  } catch (error: any) {\n    if (error.code === 'ENOENT') return;\n    throw error;\n  }\n\n  if (data.records.length) {\n    const client = new FetchClient();\n    await client.record(data.records);\n    await client.flush();\n  }\n\n  await fs.promises.unlink(telemetryFile);\n}\n"],"names":["telemetryFile","process","argv","flush","catch","fs","promises","unlink","finally","exit","json","data","readFile","JSON","parse","error","code","records","length","client","FetchClient","record"],"mappings":";;;;;gEAAe;;;;;;6BAEa;;;;;;AAG5B,MAAMA,gBAAgBC,QAAQC,IAAI,CAAC,EAAE;AAErCC,QACGC,KAAK,CAAC,IAAMC,iBAAE,CAACC,QAAQ,CAACC,MAAM,CAACP,gBAC/BQ,OAAO,CAAC,IAAMP,QAAQQ,IAAI,CAAC;AAE9B,eAAeN;IACb,IAAI,CAACH,eAAe;IAEpB,IAAIU;IACJ,IAAIC;IAEJ,IAAI;QACFD,OAAO,MAAML,iBAAE,CAACC,QAAQ,CAACM,QAAQ,CAACZ,eAAe;QACjDW,OAAOE,KAAKC,KAAK,CAACJ;IACpB,EAAE,OAAOK,OAAY;QACnB,IAAIA,MAAMC,IAAI,KAAK,UAAU;QAC7B,MAAMD;IACR;IAEA,IAAIJ,KAAKM,OAAO,CAACC,MAAM,EAAE;QACvB,MAAMC,SAAS,IAAIC,wBAAW;QAC9B,MAAMD,OAAOE,MAAM,CAACV,KAAKM,OAAO;QAChC,MAAME,OAAOhB,KAAK;IACpB;IAEA,MAAME,iBAAE,CAACC,QAAQ,CAACC,MAAM,CAACP;AAC3B"}

package/build/src/utils/telemetry/events.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "commandEvent", {
+    enumerable: true,
+    get: function() {
+        return commandEvent;
+    }
+});
+function commandEvent(commandName) {
+    return {
+        event: 'action',
+        properties: {
+            action: `expo ${commandName}`
+        }
+    };
+}
+
+//# sourceMappingURL=events.js.map

package/build/src/utils/telemetry/events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utils/telemetry/events.ts"],"sourcesContent":["import type { TelemetryRecord } from './types';\n\n/** A single command invocation, with the invoked command name */\nexport function commandEvent(commandName: string): TelemetryRecord {\n  return {\n    event: 'action',\n    properties: {\n      action: `expo ${commandName}`,\n    },\n  };\n}\n"],"names":["commandEvent","commandName","event","properties","action"],"mappings":";;;;+BAGgBA;;;eAAAA;;;AAAT,SAASA,aAAaC,WAAmB;IAC9C,OAAO;QACLC,OAAO;QACPC,YAAY;YACVC,QAAQ,CAAC,KAAK,EAAEH,aAAa;QAC/B;IACF;AACF"}