create-expo 3.6.11 → 3.6.13

package/build/{396.index.js → 303.index.js}

@@ -1,9 +1,9 @@
 "use strict";
-exports.id = 396;
-exports.ids = [396,178];
+exports.id = 303;
+exports.ids = [303,178];
 exports.modules = {
 
-/***/ 1396:
+/***/ 4303:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
@@ -29,25 +29,22 @@ var JsonFile_default = /*#__PURE__*/__webpack_require__.n(JsonFile);
 // EXTERNAL MODULE: ../../node_modules/prompts/index.js
 var prompts = __webpack_require__(2171);
 var prompts_default = /*#__PURE__*/__webpack_require__.n(prompts);
-// EXTERNAL MODULE: external "stream"
-var external_stream_ = __webpack_require__(2203);
-// EXTERNAL MODULE: ../../node_modules/tar/dist/esm/index.js + 33 modules
-var esm = __webpack_require__(3124);
-// EXTERNAL MODULE: external "util"
-var external_util_ = __webpack_require__(9023);
 // EXTERNAL MODULE: ../@expo/package-manager/build/index.js
 var build = __webpack_require__(54);
-// EXTERNAL MODULE: ../../node_modules/glob/dist/esm/index.js + 16 modules
-var dist_esm = __webpack_require__(398);
+// EXTERNAL MODULE: ../../node_modules/glob/dist/esm/index.js + 17 modules
+var esm = __webpack_require__(7314);
 // EXTERNAL MODULE: ../../node_modules/ora/index.js
 var ora = __webpack_require__(6524);
 var ora_default = /*#__PURE__*/__webpack_require__.n(ora);
+// EXTERNAL MODULE: ../../node_modules/multitars/dist/multitars.mjs
+var multitars = __webpack_require__(6471);
 // EXTERNAL MODULE: ./node_modules/picomatch/index.js
 var picomatch = __webpack_require__(8545);
 var picomatch_default = /*#__PURE__*/__webpack_require__.n(picomatch);
 ;// CONCATENATED MODULE: ./src/createFileTransform.ts
 
 
+
 const debug = __webpack_require__(7674)('expo:init:fileTransform');
 function sanitizedName(name) {
     return name
@@ -58,38 +55,34 @@ function sanitizedName(name) {
 // Directories that can be added to the template with an underscore instead of a dot, e.g. `.vscode` and be added with `_vscode`.
 const SUPPORTED_DIRECTORIES = ['eas', 'vscode', 'github', 'cursor'];
 const SUPPORTED_DIRECTORIES_PATTERN = new RegExp(`(^|/|\\\\)_(${SUPPORTED_DIRECTORIES.join('|')})(/|\\\\|$)`);
-function applyNameDuringPipe(entry, name) {
-    if (name) {
-        // Rewrite paths for bare workflow
-        entry.path = entry.path
-            .replace(/HelloWorld/g, entry.path.includes('android') ? sanitizedName(name.toLowerCase()) : sanitizedName(name))
-            .replace(/helloworld/g, sanitizedName(name).toLowerCase());
-    }
-    return entry;
-}
-const ENTRY_FILE_PATTERN = /^file$/i;
-const ENTRY_FILE_OR_DIRECTORY_PATTERN = /^(file|directory)$/i;
-function modifyFileDuringPipe(entry) {
-    if (!entry.type)
-        return entry;
-    if (ENTRY_FILE_PATTERN.test(entry.type) && external_path_default().basename(entry.path) === 'gitignore') {
-        // Rename `gitignore` because npm ignores files named `.gitignore` when publishing.
-        // See: https://github.com/npm/npm/issues/1862
-        entry.path = entry.path.replace(/gitignore$/, '.gitignore');
-    }
-    if (ENTRY_FILE_OR_DIRECTORY_PATTERN.test(entry.type)) {
+function renameDirectories(input, typeflag) {
+    if (typeflag === multitars/* TarTypeFlag */.Aq.FILE || typeflag === multitars/* TarTypeFlag */.Aq.DIRECTORY) {
         // Detect if the file contains one of the supported directories
         // and rename it to the correct format.
         // For example, if the file is `_vscode`, we want to rename it to `.vscode`.
-        // Match one instance of the supported directory name, starting with an underscore, and containing slashes on both sides.
-        entry.path = entry.path.replace(SUPPORTED_DIRECTORIES_PATTERN, (match, p1, p2, p3) => `${p1}.${p2}${p3}`);
+        input = input.replace(SUPPORTED_DIRECTORIES_PATTERN, (match, p1, p2, p3) => `${p1}.${p2}${p3}`);
+    }
+    return input;
+}
+function renameConfigs(input, typeflag) {
+    if (typeflag === multitars/* TarTypeFlag */.Aq.FILE && external_path_default().basename(input) === 'gitignore') {
+        // Rename `gitignore` because npm ignores files named `.gitignore` when publishing.
+        // See: https://github.com/npm/npm/issues/1862
+        input = input.replace(/gitignore$/, '.gitignore');
     }
-    return entry;
+    return input;
 }
-function createEntryResolver(name) {
-    return (entry) => {
-        applyNameDuringPipe(entry, name);
-        modifyFileDuringPipe(entry);
+function createEntryRenamer(name) {
+    return (input, typeflag) => {
+        if (name) {
+            // Rewrite paths for bare workflow
+            input = input
+                .replace(/HelloWorld/g, input.includes('android') ? sanitizedName(name.toLowerCase()) : sanitizedName(name))
+                .replace(/helloworld/g, sanitizedName(name).toLowerCase());
+        }
+        input = renameConfigs(input, typeflag);
+        input = renameDirectories(input, typeflag);
+        return input;
     };
 }
 function createGlobFilter(globPattern, options) {
@@ -136,6 +129,139 @@ var spawnAsync_default = /*#__PURE__*/__webpack_require__.n(spawnAsync);
 // EXTERNAL MODULE: external "os"
 var external_os_ = __webpack_require__(857);
 var external_os_default = /*#__PURE__*/__webpack_require__.n(external_os_);
+// EXTERNAL MODULE: external "stream"
+var external_stream_ = __webpack_require__(2203);
+// EXTERNAL MODULE: external "node:crypto"
+var external_node_crypto_ = __webpack_require__(7598);
+var external_node_crypto_default = /*#__PURE__*/__webpack_require__.n(external_node_crypto_);
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __webpack_require__(3024);
+var external_node_fs_default = /*#__PURE__*/__webpack_require__.n(external_node_fs_);
+// EXTERNAL MODULE: external "node:path"
+var external_node_path_ = __webpack_require__(6760);
+var external_node_path_default = /*#__PURE__*/__webpack_require__.n(external_node_path_);
+// EXTERNAL MODULE: external "node:stream"
+var external_node_stream_ = __webpack_require__(7075);
+;// CONCATENATED MODULE: ./src/utils/tar.ts
+// NOTE(@kitten): Based on @expo/cli/src/utils/tar.ts
+// Keep in sync with that version of this module
+
+
+
+
+
+// Modified:
+const tar_debug = __webpack_require__(7674)('create-expo:tar');
+class ChecksumStream extends TransformStream {
+    hash;
+    constructor(algorithm) {
+        super({
+            transform: (chunk, controller) => {
+                this.hash.update(chunk);
+                controller.enqueue(chunk);
+            },
+        });
+        this.hash = external_node_crypto_default().createHash(algorithm);
+    }
+    digest(encoding) {
+        return this.hash.digest(encoding);
+    }
+}
+async function extractStream(input, output, options = {}) {
+    output = external_node_path_default().resolve(output);
+    await external_node_fs_default().promises.mkdir(output, { recursive: true });
+    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 */.PJ)(body)) {
+        let name = external_node_path_default().normalize(file.name);
+        if (filter && !filter(name, file.typeflag)) {
+            tar_debug(`filtered: ${external_node_path_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((external_node_path_default()).sep);
+            if (sepIdx > -1) {
+                name = name.slice(sepIdx + 1);
+            }
+            else {
+                break;
+            }
+        }
+        const resolved = external_node_path_default().resolve(output, name);
+        if (!resolved.startsWith(output)) {
+            tar_debug(`skip: ${resolved}`);
+            continue;
+        }
+        const parent = external_node_path_default().dirname(resolved);
+        if (parent !== output) {
+            let exists = false;
+            try {
+                const stat = await external_node_fs_default().promises.lstat(parent);
+                if (stat.isSymbolicLink() || (!stat.isDirectory() && !stat.isFile())) {
+                    tar_debug(`skip: ${resolved}`);
+                    continue;
+                }
+                else if (stat.isDirectory()) {
+                    exists = true;
+                }
+            }
+            catch { }
+            if (!exists) {
+                tar_debug(`mkdir(p): ${parent}`);
+                await external_node_fs_default().promises.mkdir(parent, { recursive: true });
+            }
+        }
+        switch (file.typeflag) {
+            case multitars/* TarTypeFlag */.Aq.FILE:
+                tar_debug(`write(${file.mode.toString(8)}): ${resolved}`);
+                await external_node_fs_default().promises.writeFile(resolved, (0,multitars/* streamToAsyncIterable */.WT)(file.stream()), {
+                    mode: file.mode,
+                });
+                break;
+            case multitars/* TarTypeFlag */.Aq.DIRECTORY:
+                tar_debug(`mkdir(${file.mode.toString(8)}): ${resolved}`);
+                try {
+                    await external_node_fs_default().promises.mkdir(resolved, { mode: file.mode });
+                }
+                catch (error) {
+                    if (error.code !== 'EEXIST') {
+                        throw error;
+                    }
+                }
+                break;
+            case multitars/* TarTypeFlag */.Aq.SYMLINK:
+            case multitars/* TarTypeFlag */.Aq.LINK: {
+                const target = external_node_path_default().resolve(parent, file.linkname ?? '');
+                if (!target.startsWith(output) || target === parent) {
+                    tar_debug(`skip: ${resolved} -> ${target}`);
+                    continue;
+                }
+                if (file.typeflag === multitars/* TarTypeFlag */.Aq.LINK) {
+                    tar_debug(`link: ${resolved} -> ${target}`);
+                    await external_node_fs_default().promises.link(target, resolved);
+                }
+                else {
+                    const stat = await external_node_fs_default().promises.lstat(target).catch(() => null);
+                    const type = stat?.isDirectory() ? 'dir' : 'file';
+                    tar_debug(`symlink(${type}): ${resolved} -> ${target}`);
+                    await external_node_fs_default().promises.symlink(target, resolved, type);
+                }
+                break;
+            }
+        }
+    }
+    return checksumStream.digest('hex');
+}
+/** Extract a tar using built-in tools if available and falling back on Node.js. */
+async function extractAsync(input, output, options) {
+    await extractStream(Readable.toWeb(fs.createReadStream(input)), output, options);
+}
+
 ;// CONCATENATED MODULE: ./src/legacyTemplates.ts
 
 
@@ -198,10 +324,7 @@ async function promptTemplateAsync() {
 
 
 
-
 const npm_debug = __webpack_require__(7674)('expo:init:npm');
-// @ts-ignore
-const pipeline = (0,external_util_.promisify)(external_stream_.Stream.pipeline);
 function getTemporaryCacheFilePath(subdir = 'template-cache') {
     // This is cleared when the device restarts
     return external_path_default().join(external_os_default().tmpdir(), '.create-expo-app', subdir);
@@ -264,22 +387,18 @@ function applyKnownNpmPackageNameRules(name) {
         .normalize('NFD')
         .replace(/[\u0300-\u036f]/g, '') || null);
 }
-async function extractLocalNpmTarballAsync(tarFilePath, props) {
-    const readStream = external_fs_default().createReadStream(tarFilePath);
-    await extractNpmTarballAsync(readStream, props);
+/**
+ * Extracts a tarball stream to a directory.
+ */
+async function extractNpmTarballAsync(stream, output, props) {
+    return await extractStream(stream, output, {
+        filter: props.filter,
+        rename: createEntryRenamer(props.expName),
+        strip: props.strip ?? 1,
+    });
 }
-async function extractNpmTarballAsync(stream, props) {
-    if (!stream) {
-        throw new Error('Missing stream');
-    }
-    const { cwd, strip, name, fileList = [], filter } = props;
-    await external_fs_default().promises.mkdir(cwd, { recursive: true });
-    await pipeline(stream, (0,esm/* extract */.o6)({
-        cwd,
-        filter,
-        onentry: createEntryResolver(name),
-        strip: strip ?? 1,
-    }, fileList));
+async function extractLocalNpmTarballAsync(tarFilePath, output, props) {
+    return await extractNpmTarballAsync(external_stream_.Readable.toWeb(external_fs_default().createReadStream(tarFilePath)), output, props);
 }
 async function npmPackAsync(packageName, cwd = undefined, ...props) {
     const npm = getNpmBin();
@@ -354,7 +473,7 @@ async function fileExistsAsync(path) {
         return false;
     }
 }
-async function downloadAndExtractNpmModuleAsync(npmName, props) {
+async function downloadAndExtractNpmModuleAsync(npmName, output, props) {
     const cachePath = getTemporaryCacheFilePath();
     npm_debug(`Looking for NPM tarball (id: ${npmName}, cache: ${cachePath})`);
     await external_fs_default().promises.mkdir(cachePath, { recursive: true });
@@ -374,9 +493,8 @@ async function downloadAndExtractNpmModuleAsync(npmName, props) {
         throw error;
     }
     try {
-        await extractLocalNpmTarballAsync(cacheFilename, {
-            cwd: props.cwd,
-            name: props.name,
+        return await extractLocalNpmTarballAsync(cacheFilename, output, {
+            expName: props.expName,
         });
     }
     catch (error) {
@@ -389,7 +507,6 @@ async function downloadAndExtractNpmModuleAsync(npmName, props) {
 
 
 
-
 const github_debug = __webpack_require__(7674)('expo:init:github');
 // See: https://github.com/expo/expo/blob/a5a6eecb082b2c7a7fc9956141738231c7df473f/packages/%40expo/cli/src/prebuild/resolveTemplate.ts#L60-L84
 async function getGitHubRepoAsync(url) {
@@ -423,7 +540,7 @@ async function isValidGitHubRepoAsync(repo) {
     return response.ok;
 }
 // See: https://github.com/expo/expo/blob/a5a6eecb082b2c7a7fc9956141738231c7df473f/packages/%40expo/cli/src/utils/npm.ts#L134-L139
-async function extractRemoteGitHubTarballAsync(url, repo, props) {
+async function extractRemoteGitHubTarballAsync(url, repo, output, props) {
     const response = await fetch(url);
     if (!response.ok)
         throw new Error(`Unexpected response: ${response.statusText} (${url})`);
@@ -434,18 +551,20 @@ async function extractRemoteGitHubTarballAsync(url, repo, props) {
     // Remove the (sub)directory paths, and the root folder added by GitHub
     const strip = directory.length + 1;
     // Only extract the relevant (sub)directories, ignoring irrelevant files
-    // The filder auto-ignores dotfiles, unless explicitly included
+    // The filter auto-ignores dotfiles, unless explicitly included
     const filter = createGlobFilter(!directory.length
         ? ['*/**', '*/ios/.xcode.env']
         : [`*/${directory.join('/')}/**`, `*/${directory.join('/')}/ios/.xcode.env`], {
         // Always ignore the `.xcworkspace` folder
         ignore: ['**/ios/*.xcworkspace/**'],
     });
-    await extractNpmTarballAsync(
-    // @ts-expect-error see https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/65542
-    external_stream_.Readable.fromWeb(response.body), { ...props, filter, strip });
+    return await extractNpmTarballAsync(response.body, output, {
+        ...props,
+        filter,
+        strip,
+    });
 }
-async function downloadAndExtractGitHubRepositoryAsync(repoUrl, props) {
+async function downloadAndExtractGitHubRepositoryAsync(repoUrl, output, props) {
     github_debug('Looking for GitHub repository');
     const info = await getGitHubRepoAsync(repoUrl);
     const isValid = await isValidGitHubRepoAsync(info);
@@ -455,7 +574,7 @@ async function downloadAndExtractGitHubRepositoryAsync(repoUrl, props) {
     const url = `https://codeload.github.com/${info.owner}/${info.name}/tar.gz/${info.branch}`;
     github_debug('Resolved GitHub repository', info);
     github_debug('Downloading GitHub repository from:', url);
-    await extractRemoteGitHubTarballAsync(url, info, props);
+    return await extractRemoteGitHubTarballAsync(url, info, output, props);
 }
 
 ;// CONCATENATED MODULE: ./src/Template.ts
@@ -562,16 +681,14 @@ async function extractAndPrepareTemplateAppAsync(projectRoot, { npmPackage }) {
     Template_debug(`Extracting template app (pkg: ${npmPackage}, projectName: ${projectName})`);
     const { type, uri } = resolvePackageModuleId(npmPackage || 'expo-template-default');
     if (type === 'repository') {
-        await downloadAndExtractGitHubRepositoryAsync(uri, {
-            cwd: projectRoot,
-            name: projectName,
+        await downloadAndExtractGitHubRepositoryAsync(uri, projectRoot, {
+            expName: projectName,
         });
     }
     else {
         const resolvedUri = type === 'file' ? uri : getResolvedTemplateName(applyBetaTag(uri));
-        await downloadAndExtractNpmModuleAsync(resolvedUri, {
-            cwd: projectRoot,
-            name: projectName,
+        await downloadAndExtractNpmModuleAsync(resolvedUri, projectRoot, {
+            expName: projectName,
             disableCache: type === 'file',
         });
     }
@@ -606,7 +723,7 @@ function escapeXMLCharacters(original) {
  * specified.
  *
  * By convention, the app name of all templates is "HelloWorld". During
- * extraction, filepaths are transformed via `createEntryResolver()` in
+ * extraction, filepaths are transformed via `createEntryRenamer()` in
  * `createFileTransform.ts`, but the contents of files are left untouched.
  * Technically, the contents used to be transformed during extraction as well,
  * but due to poor configurability, we've moved to a post-extraction approach.
@@ -669,7 +786,7 @@ renameConfig: userConfig, }) {
     let config = userConfig ?? defaultRenameConfig;
     // Strip comments, trim whitespace, and remove empty lines.
     config = config.map((line) => line.split(/(?<!\\)#/, 2)[0].trim()).filter((line) => line !== '');
-    return await (0,dist_esm/* glob */.TI)(config, {
+    return await (0,esm/* glob */.TI)(config, {
         cwd,
         // `true` is consistent with .gitignore. Allows `*.xml` to match .xml files
         // in all subdirs.
@@ -892,11 +1009,7 @@ function logNewSection(title) {
 
 
 
-
-
-
 const Examples_debug = __webpack_require__(7674)('expo:init:template');
-const Examples_pipeline = (0,external_util_.promisify)(external_stream_.Stream.pipeline);
 /** List all existing examples directory from https://github.com/expo/examples. */
 async function listExamplesAsync() {
     const response = await fetch('https://api.github.com/repos/expo/examples/contents');
@@ -963,13 +1076,12 @@ async function downloadAndExtractExampleAsync(root, name) {
         Examples_debug(`Failed to fetch the examples code, Github responded without content, received status "${response.status}"`);
         throw new Error('Failed to fetch the examples code from https://github.com/expo/examples');
     }
-    await Examples_pipeline(
-    // @ts-expect-error see https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/65542
-    external_stream_.Readable.fromWeb(response.body), (0,esm/* extract */.o6)({
-        cwd: root,
-        onentry: createEntryResolver(projectName),
+    const prefix = `examples-master/${name}/`;
+    await extractNpmTarballAsync(response.body, root, {
+        expName: projectName,
         strip: 2,
-    }, [`examples-master/${name}`]));
+        filter: (entryName) => entryName.startsWith(prefix),
+    });
     const files = await getTemplateFilesToRenameAsync({ cwd: root });
     await renameTemplateAppNameAsync({
         cwd: root,