@iconify/tools 4.2.0 → 5.0.0-beta.2

package/lib/download/api/queue.d.ts

@@ -10,23 +10,22 @@ type GetConcurrentQueryCallback<T> = (index: number) => Promise<T>;
  * Parameters
  */
 interface ConcurrentQueriesCommonParams<T> {
-    limit?: number;
-    retries?: number;
-    onError?: (index: number, error: unknown, params: ConcurrentQueriesParams<T>) => void | Promise<void>;
-    onSuccess?: (index: number, params: ConcurrentQueriesParams<T>, result: T) => void;
-    onStart?: (index: number, params: ConcurrentQueriesParams<T>) => void;
+  limit?: number;
+  retries?: number;
+  onError?: (index: number, error: unknown, params: ConcurrentQueriesParams<T>) => void | Promise<void>;
+  onSuccess?: (index: number, params: ConcurrentQueriesParams<T>, result: T) => void;
+  onStart?: (index: number, params: ConcurrentQueriesParams<T>) => void;
 }
 interface ConcurrentQueriesParamsWithCount<T> extends ConcurrentQueriesCommonParams<T> {
-    total: number;
-    callback: (index: number) => Promise<T>;
+  total: number;
+  callback: (index: number) => Promise<T>;
 }
 interface ConcurrentQueriesParamsWithPromises<T> extends ConcurrentQueriesCommonParams<T> {
-    promises: Promise<T>[];
+  promises: Promise<T>[];
 }
 type ConcurrentQueriesParams<T> = ConcurrentQueriesParamsWithCount<T> | ConcurrentQueriesParamsWithPromises<T>;
 /**
  * Runs concurrent async operations
  */
 declare function runConcurrentQueries<T>(params: ConcurrentQueriesParams<T>): Promise<T[]>;
-
-export { type ConcurrentQueriesCommonParams, type ConcurrentQueriesParams, type ConcurrentQueriesParamsWithCount, type ConcurrentQueriesParamsWithPromises, type GetConcurrentQueryCallback, defaultQueueParams, runConcurrentQueries };
+export { ConcurrentQueriesCommonParams, ConcurrentQueriesParams, ConcurrentQueriesParamsWithCount, ConcurrentQueriesParamsWithPromises, GetConcurrentQueryCallback, defaultQueueParams, runConcurrentQueries };

package/lib/download/api/queue.js

@@ -0,0 +1,94 @@
+/**
+* Default parameters
+*/
+const defaultQueueParams = {
+	limit: 5,
+	retries: 3
+};
+/**
+* Runs concurrent async operations
+*/
+function runConcurrentQueries(params) {
+	const allParams = {
+		...defaultQueueParams,
+		...params
+	};
+	const paramsWithCount = allParams;
+	const paramsWithPromises = allParams;
+	const isCallback = typeof paramsWithCount.total === "number";
+	const count = isCallback ? paramsWithCount.total : paramsWithPromises.promises.length;
+	const limit = Math.max(1, Math.min(allParams.limit || 1, count));
+	const retries = Math.max(1, allParams.retries || 1);
+	const results = Array(count).fill(void 0);
+	let nextIndex = 0;
+	const resolving = /* @__PURE__ */ new Set();
+	let rejected = false;
+	let resolved = false;
+	return new Promise((resolve, reject) => {
+		function resolvedItem() {
+			if (rejected || resolved) return;
+			if (!resolving.size && nextIndex > count) {
+				resolved = true;
+				resolve(results);
+				return;
+			}
+			if (resolving.size < limit && nextIndex <= count) startNext();
+		}
+		function fail(index, err) {
+			function done(failed) {
+				resolving.delete(index);
+				if (failed) {
+					rejected = true;
+					reject(err);
+				} else resolvedItem();
+			}
+			if (allParams.onError) {
+				let retry;
+				try {
+					retry = allParams.onError(index, err, params);
+				} catch (err2) {
+					err = err2;
+					done(true);
+					return;
+				}
+				if (retry instanceof Promise) {
+					retry.then(() => {
+						done(false);
+					}).catch((err2) => {
+						err = err2;
+						done(true);
+					});
+					return;
+				}
+				done(false);
+			} else done(true);
+		}
+		function run(index, retry) {
+			resolving.add(index);
+			const p = isCallback ? paramsWithCount.callback(index) : paramsWithPromises.promises[index];
+			allParams.onStart?.(index, params);
+			p.then((value) => {
+				resolving.delete(index);
+				results[index] = value;
+				allParams.onSuccess?.(index, params, value);
+				resolvedItem();
+			}).catch((err) => {
+				if (retry < retries) setTimeout(() => {
+					run(index, retry + 1);
+				});
+				else if (!rejected) fail(index, err);
+			});
+		}
+		function startNext() {
+			const index = nextIndex++;
+			if (index >= count) {
+				resolvedItem();
+				return;
+			}
+			run(index, 0);
+		}
+		for (let i = 0; i < limit; i++) startNext();
+	});
+}
+
+export { defaultQueueParams, runConcurrentQueries };

package/lib/download/api/types.d.ts

@@ -2,16 +2,15 @@
  * API Cache
  */
 interface APICacheOptions {
-    dir: string;
-    ttl: number;
+  dir: string;
+  ttl: number;
 }
 /**
  * Params
  */
 interface APIQueryParams {
-    uri: string;
-    params?: URLSearchParams;
-    headers?: Record<string, string>;
+  uri: string;
+  params?: URLSearchParams;
+  headers?: Record<string, string>;
 }
-
-export type { APICacheOptions, APIQueryParams };
+export { APICacheOptions, APIQueryParams };

package/lib/download/api/types.js

@@ -0,0 +1 @@
+export {  };

package/lib/download/git/branch.d.ts

@@ -1,8 +1,6 @@
-import { ExportTargetOptions } from '../../export/helpers/prepare.js';
-
+import { ExportTargetOptions } from "../../export/helpers/prepare.js";
 /**
  * Get current branch from cloned git repo
  */
 declare function getGitRepoBranch(options: ExportTargetOptions, checkout?: string): Promise<string>;
-
-export { getGitRepoBranch };
+export { getGitRepoBranch };

package/lib/download/git/branch.js

@@ -0,0 +1,15 @@
+import { execAsync } from "../../misc/exec.js";
+
+/**
+* Get current branch from cloned git repo
+*/
+async function getGitRepoBranch(options, checkout) {
+	const branch = (await execAsync("git branch --show-current", { cwd: options.target })).stdout.trim();
+	if (typeof checkout === "string" && branch !== checkout) {
+		await execAsync(`git checkout ${checkout} "${options.target}"`);
+		return await getGitRepoBranch(options);
+	}
+	return branch;
+}
+
+export { getGitRepoBranch };

package/lib/download/git/hash.d.ts

@@ -1,8 +1,6 @@
-import { ExportTargetOptions } from '../../export/helpers/prepare.js';
-
+import { ExportTargetOptions } from "../../export/helpers/prepare.js";
 /**
  * Get latest hash from cloned git repo
  */
 declare function getGitRepoHash(options: ExportTargetOptions): Promise<string>;
-
-export { getGitRepoHash };
+export { getGitRepoHash };

package/lib/download/git/hash.js

@@ -0,0 +1,10 @@
+import { execAsync } from "../../misc/exec.js";
+
+/**
+* Get latest hash from cloned git repo
+*/
+async function getGitRepoHash(options) {
+	return (await execAsync("git rev-parse HEAD", { cwd: options.target })).stdout.trim();
+}
+
+export { getGitRepoHash };

package/lib/download/git/index.d.ts

@@ -1,29 +1,27 @@
-import { ExportTargetOptions } from '../../export/helpers/prepare.js';
-import { DocumentNotModified } from '../types/modified.js';
-import { DownloadSourceMixin } from '../types/sources.js';
-
+import { ExportTargetOptions } from "../../export/helpers/prepare.js";
+import { DocumentNotModified } from "../types/modified.js";
+import { DownloadSourceMixin } from "../types/sources.js";
 interface IfModifiedSinceOption {
-    ifModifiedSince: string | true | DownloadGitRepoResult;
+  ifModifiedSince: string | true | DownloadGitRepoResult;
 }
 /**
  * Options for downloadGitRepo()
  */
 interface DownloadGitRepoOptions extends ExportTargetOptions, Partial<IfModifiedSinceOption> {
-    remote: string;
-    branch: string;
-    log?: boolean;
+  remote: string;
+  branch: string;
+  log?: boolean;
 }
 /**
  * Result
  */
 interface DownloadGitRepoResult extends DownloadSourceMixin<'git'> {
-    contentsDir: string;
-    hash: string;
+  contentsDir: string;
+  hash: string;
 }
 /**
  * Download Git repo
  */
 declare function downloadGitRepo<T extends IfModifiedSinceOption & DownloadGitRepoOptions>(options: T): Promise<DownloadGitRepoResult | DocumentNotModified>;
 declare function downloadGitRepo(options: DownloadGitRepoOptions): Promise<DownloadGitRepoResult>;
-
-export { type DownloadGitRepoOptions, type DownloadGitRepoResult, downloadGitRepo };
+export { DownloadGitRepoOptions, DownloadGitRepoResult, downloadGitRepo };

package/lib/download/git/index.js

@@ -0,0 +1,39 @@
+import { prepareDirectoryForExport } from "../../export/helpers/prepare.js";
+import { execAsync } from "../../misc/exec.js";
+import { getGitRepoBranch } from "./branch.js";
+import { getGitRepoHash } from "./hash.js";
+import { resetGitRepoContents } from "./reset.js";
+
+async function downloadGitRepo(options) {
+	const { remote, branch } = options;
+	const hasHashInTarget = options.target.includes("{hash}");
+	const ifModifiedSince = options.ifModifiedSince;
+	if (ifModifiedSince || hasHashInTarget) {
+		const latestHash = (await execAsync(`git ls-remote ${remote} --branch ${branch}`)).stdout.split(/\s/).shift();
+		if (hasHashInTarget) options.target = options.target.replace("{hash}", latestHash);
+		try {
+			await getGitRepoBranch(options, branch);
+			if (ifModifiedSince) {
+				if (latestHash === (ifModifiedSince === true ? await getGitRepoHash(options) : typeof ifModifiedSince === "string" ? ifModifiedSince : ifModifiedSince.downloadType === "git" ? ifModifiedSince.hash : null)) {
+					await resetGitRepoContents(options.target);
+					return "not_modified";
+				}
+			}
+		} catch {}
+	}
+	const target = options.target = await prepareDirectoryForExport({
+		...options,
+		cleanup: true
+	});
+	if (options.log) console.log(`Cloning ${remote}#${branch} to ${target}`);
+	await execAsync(`git clone --branch ${branch} --no-tags --depth 1 ${remote} "${target}"`);
+	const hash = await getGitRepoHash(options);
+	await getGitRepoBranch(options, branch);
+	return {
+		downloadType: "git",
+		contentsDir: target,
+		hash
+	};
+}
+
+export { downloadGitRepo };

package/lib/download/git/reset.d.ts

@@ -2,5 +2,4 @@
  * Reset Git repo contents
  */
 declare function resetGitRepoContents(target: string): Promise<void>;
-
-export { resetGitRepoContents };
+export { resetGitRepoContents };

package/lib/download/git/reset.js

@@ -0,0 +1,12 @@
+import { execAsync } from "../../misc/exec.js";
+import "../../index.js";
+
+/**
+* Reset Git repo contents
+*/
+async function resetGitRepoContents(target) {
+	await execAsync("git add -A", { cwd: target });
+	await execAsync("git reset --hard --quiet", { cwd: target });
+}
+
+export { resetGitRepoContents };

package/lib/download/github/hash.d.ts

@@ -1,8 +1,6 @@
-import { GitHubAPIOptions } from './types.js';
-
+import { GitHubAPIOptions } from "./types.js";
 /**
  * Get latest hash from GitHub using API
  */
 declare function getGitHubRepoHash(options: GitHubAPIOptions): Promise<string>;
-
-export { getGitHubRepoHash };
+export { getGitHubRepoHash };

package/lib/download/github/hash.js

@@ -0,0 +1,20 @@
+import { sendAPIQuery } from "../api/index.js";
+
+/**
+* Get latest hash from GitHub using API
+*/
+async function getGitHubRepoHash(options) {
+	const data = await sendAPIQuery({
+		uri: `https://api.github.com/repos/${options.user}/${options.repo}/branches/${options.branch}`,
+		headers: {
+			Accept: "application/vnd.github.v3+json",
+			Authorization: "token " + options.token
+		}
+	});
+	if (typeof data !== "string") throw new Error(`Error downloading data from GitHub API: ${data}`);
+	const hash = JSON.parse(data)?.commit?.sha;
+	if (typeof hash !== "string") throw new Error("Error parsing GitHub API response");
+	return hash;
+}
+
+export { getGitHubRepoHash };

package/lib/download/github/index.d.ts

@@ -1,31 +1,29 @@
-import { ExportTargetOptions } from '../../export/helpers/prepare.js';
-import { DocumentNotModified } from '../types/modified.js';
-import { GitHubAPIOptions } from './types.js';
-import { DownloadSourceMixin } from '../types/sources.js';
-
+import { ExportTargetOptions } from "../../export/helpers/prepare.js";
+import { DocumentNotModified } from "../types/modified.js";
+import { DownloadSourceMixin } from "../types/sources.js";
+import { GitHubAPIOptions } from "./types.js";
 interface IfModifiedSinceOption {
-    ifModifiedSince: string | DownloadGitHubRepoResult;
+  ifModifiedSince: string | DownloadGitHubRepoResult;
 }
 /**
  * Options for downloadGitHubRepo()
  */
 interface DownloadGitHubRepoOptions extends ExportTargetOptions, GitHubAPIOptions, Partial<IfModifiedSinceOption> {
-    cleanupOldFiles?: boolean;
-    cleanupOldDirectories?: boolean;
-    log?: boolean;
+  cleanupOldFiles?: boolean;
+  cleanupOldDirectories?: boolean;
+  log?: boolean;
 }
 /**
  * Result
  */
 interface DownloadGitHubRepoResult extends DownloadSourceMixin<'github'> {
-    rootDir: string;
-    contentsDir: string;
-    hash: string;
+  rootDir: string;
+  contentsDir: string;
+  hash: string;
 }
 /**
  * Download GitHub repo using API
  */
 declare function downloadGitHubRepo<T extends IfModifiedSinceOption & DownloadGitHubRepoOptions>(options: T): Promise<DownloadGitHubRepoResult | DocumentNotModified>;
 declare function downloadGitHubRepo(options: DownloadGitHubRepoOptions): Promise<DownloadGitHubRepoResult>;
-
-export { type DownloadGitHubRepoOptions, type DownloadGitHubRepoResult, downloadGitHubRepo };
+export { DownloadGitHubRepoOptions, DownloadGitHubRepoResult, downloadGitHubRepo };

package/lib/download/github/index.js

@@ -0,0 +1,66 @@
+import { prepareDirectoryForExport } from "../../export/helpers/prepare.js";
+import { getGitHubRepoHash } from "./hash.js";
+import { downloadFile } from "../api/download.js";
+import { unzip } from "../helpers/unzip.js";
+import { promises } from "fs";
+
+/**
+* Find matching directories
+*/
+async function findMatchingDirs(rootDir, hash) {
+	const matches = [];
+	const files = await promises.readdir(rootDir);
+	for (let i = 0; i < files.length; i++) {
+		const file = files[i];
+		const lastChunk = file.split("-").pop();
+		if (lastChunk.length < 4 || lastChunk !== hash.slice(0, lastChunk.length)) continue;
+		if ((await promises.stat(rootDir + "/" + file)).isDirectory()) matches.push(file);
+	}
+	return matches;
+}
+async function downloadGitHubRepo(options) {
+	const hash = await getGitHubRepoHash(options);
+	const ifModifiedSince = options.ifModifiedSince;
+	if (ifModifiedSince) {
+		if (hash === (typeof ifModifiedSince === "string" ? ifModifiedSince : ifModifiedSince.downloadType === "github" ? ifModifiedSince.hash : null)) return "not_modified";
+	}
+	options.target = options.target.replace("{hash}", hash);
+	const rootDir = options.target = await prepareDirectoryForExport(options);
+	const archiveTarget = rootDir + "/" + hash + ".zip";
+	let exists = false;
+	try {
+		exists = (await promises.stat(archiveTarget)).isFile();
+	} catch (err) {}
+	if (!exists) await downloadFile({
+		uri: `https://api.github.com/repos/${options.user}/${options.repo}/zipball/${hash}`,
+		headers: {
+			Accept: "application/vnd.github.v3+json",
+			Authorization: "token " + options.token
+		}
+	}, archiveTarget);
+	const files = await promises.readdir(rootDir);
+	const hashSearch = "-" + hash;
+	for (let i = 0; i < files.length; i++) {
+		if (files[i] === hash + ".zip") continue;
+		const filename = rootDir + "/" + files[i];
+		const stat = await promises.lstat(filename);
+		const isDir = stat.isDirectory();
+		if (stat.isSymbolicLink() || isDir && filename.slice(0 - hashSearch.length) === hashSearch || isDir && options.cleanupOldDirectories !== false || !isDir && options.cleanupOldFiles) try {
+			await promises.rm(filename, {
+				force: true,
+				recursive: true
+			});
+		} catch (err) {}
+	}
+	await unzip(archiveTarget, rootDir);
+	const matchingDirs = await findMatchingDirs(rootDir, hash);
+	if (matchingDirs.length !== 1) throw new Error(`Error unpacking ${hash}.zip`);
+	return {
+		downloadType: "github",
+		rootDir,
+		contentsDir: rootDir + "/" + matchingDirs[0],
+		hash
+	};
+}
+
+export { downloadGitHubRepo };

package/lib/download/github/types.d.ts

@@ -2,10 +2,9 @@
  * API options
  */
 interface GitHubAPIOptions {
-    token: string;
-    user: string;
-    repo: string;
-    branch: string;
+  token: string;
+  user: string;
+  repo: string;
+  branch: string;
 }
-
-export type { GitHubAPIOptions };
+export { GitHubAPIOptions };

package/lib/download/github/types.js

@@ -0,0 +1 @@
+export {  };

package/lib/download/gitlab/hash.d.ts

@@ -1,8 +1,6 @@
-import { GitLabAPIOptions } from './types.js';
-
+import { GitLabAPIOptions } from "./types.js";
 /**
  * Get latest hash from GitHub using API
  */
 declare function getGitLabRepoHash(options: GitLabAPIOptions): Promise<string>;
-
-export { getGitLabRepoHash };
+export { getGitLabRepoHash };

package/lib/download/gitlab/hash.js

@@ -0,0 +1,19 @@
+import { sendAPIQuery } from "../api/index.js";
+import { defaultGitLabBaseURI } from "./types.js";
+
+/**
+* Get latest hash from GitHub using API
+*/
+async function getGitLabRepoHash(options) {
+	const data = await sendAPIQuery({
+		uri: `${options.uri || defaultGitLabBaseURI}/${options.project}/repository/branches/${options.branch}/`,
+		headers: { Authorization: "token " + options.token }
+	});
+	if (typeof data !== "string") throw new Error(`Error downloading data from GitLab API: ${data}`);
+	const content = JSON.parse(data);
+	const item = (content instanceof Array ? content : [content]).find((item$1) => item$1.name === options.branch && typeof item$1.commit.id === "string");
+	if (!item) throw new Error("Error parsing GitLab API response");
+	return item.commit.id;
+}
+
+export { getGitLabRepoHash };

package/lib/download/gitlab/index.d.ts

@@ -1,31 +1,29 @@
-import { ExportTargetOptions } from '../../export/helpers/prepare.js';
-import { DocumentNotModified } from '../types/modified.js';
-import { GitLabAPIOptions } from './types.js';
-import { DownloadSourceMixin } from '../types/sources.js';
-
+import { ExportTargetOptions } from "../../export/helpers/prepare.js";
+import { DocumentNotModified } from "../types/modified.js";
+import { DownloadSourceMixin } from "../types/sources.js";
+import { GitLabAPIOptions } from "./types.js";
 interface IfModifiedSinceOption {
-    ifModifiedSince: string | DownloadGitLabRepoResult;
+  ifModifiedSince: string | DownloadGitLabRepoResult;
 }
 /**
  * Options for downloadGitLabRepo()
  */
 interface DownloadGitLabRepoOptions extends ExportTargetOptions, GitLabAPIOptions, Partial<IfModifiedSinceOption> {
-    cleanupOldFiles?: boolean;
-    cleanupOldDirectories?: boolean;
-    log?: boolean;
+  cleanupOldFiles?: boolean;
+  cleanupOldDirectories?: boolean;
+  log?: boolean;
 }
 /**
  * Result
  */
 interface DownloadGitLabRepoResult extends DownloadSourceMixin<'gitlab'> {
-    rootDir: string;
-    contentsDir: string;
-    hash: string;
+  rootDir: string;
+  contentsDir: string;
+  hash: string;
 }
 /**
  * Download GitLab repo using API
  */
 declare function downloadGitLabRepo<T extends IfModifiedSinceOption & DownloadGitLabRepoOptions>(options: T): Promise<DownloadGitLabRepoResult | DocumentNotModified>;
 declare function downloadGitLabRepo(options: DownloadGitLabRepoOptions): Promise<DownloadGitLabRepoResult>;
-
-export { type DownloadGitLabRepoOptions, type DownloadGitLabRepoResult, downloadGitLabRepo };
+export { DownloadGitLabRepoOptions, DownloadGitLabRepoResult, downloadGitLabRepo };

package/lib/download/gitlab/index.js

@@ -0,0 +1,64 @@
+import { prepareDirectoryForExport } from "../../export/helpers/prepare.js";
+import { downloadFile } from "../api/download.js";
+import { unzip } from "../helpers/unzip.js";
+import { defaultGitLabBaseURI } from "./types.js";
+import { getGitLabRepoHash } from "./hash.js";
+import { promises } from "fs";
+
+/**
+* Find matching directories
+*/
+async function findMatchingDirs(rootDir, hash) {
+	const matches = [];
+	const files = await promises.readdir(rootDir);
+	for (let i = 0; i < files.length; i++) {
+		const file = files[i];
+		const lastChunk = file.split("-").pop();
+		if (lastChunk.length < 4 || lastChunk !== hash.slice(0, lastChunk.length)) continue;
+		if ((await promises.stat(rootDir + "/" + file)).isDirectory()) matches.push(file);
+	}
+	return matches;
+}
+async function downloadGitLabRepo(options) {
+	const hash = await getGitLabRepoHash(options);
+	const ifModifiedSince = options.ifModifiedSince;
+	if (ifModifiedSince) {
+		if (hash === (typeof ifModifiedSince === "string" ? ifModifiedSince : ifModifiedSince.downloadType === "gitlab" ? ifModifiedSince.hash : null)) return "not_modified";
+	}
+	options.target = options.target.replace("{hash}", hash);
+	const rootDir = options.target = await prepareDirectoryForExport(options);
+	const archiveTarget = rootDir + "/" + hash + ".zip";
+	let exists = false;
+	try {
+		exists = (await promises.stat(archiveTarget)).isFile();
+	} catch (err) {}
+	if (!exists) await downloadFile({
+		uri: `${options.uri || defaultGitLabBaseURI}/${options.project}/repository/archive.zip?sha=${hash}`,
+		headers: { Authorization: "token " + options.token }
+	}, archiveTarget);
+	const files = await promises.readdir(rootDir);
+	const hashSearch = "-" + hash;
+	for (let i = 0; i < files.length; i++) {
+		if (files[i] === hash + ".zip") continue;
+		const filename = rootDir + "/" + files[i];
+		const stat = await promises.lstat(filename);
+		const isDir = stat.isDirectory();
+		if (stat.isSymbolicLink() || isDir && filename.slice(0 - hashSearch.length) === hashSearch || isDir && options.cleanupOldDirectories !== false || !isDir && options.cleanupOldFiles) try {
+			await promises.rm(filename, {
+				force: true,
+				recursive: true
+			});
+		} catch (err) {}
+	}
+	await unzip(archiveTarget, rootDir);
+	const matchingDirs = await findMatchingDirs(rootDir, hash);
+	if (matchingDirs.length !== 1) throw new Error(`Error unpacking ${hash}.zip`);
+	return {
+		downloadType: "gitlab",
+		rootDir,
+		contentsDir: rootDir + "/" + matchingDirs[0],
+		hash
+	};
+}
+
+export { downloadGitLabRepo };

package/lib/download/gitlab/types.d.ts

@@ -2,14 +2,13 @@
  * API options
  */
 interface GitLabAPIOptions {
-    uri?: string;
-    token: string;
-    project: string;
-    branch: string;
+  uri?: string;
+  token: string;
+  project: string;
+  branch: string;
 }
 /**
  * Default base URI for GitLab API
  */
 declare const defaultGitLabBaseURI = "https://gitlab.com/api/v4/projects";
-
-export { type GitLabAPIOptions, defaultGitLabBaseURI };
+export { GitLabAPIOptions, defaultGitLabBaseURI };

package/lib/download/gitlab/types.js

@@ -0,0 +1,6 @@
+/**
+* Default base URI for GitLab API
+*/
+const defaultGitLabBaseURI = "https://gitlab.com/api/v4/projects";
+
+export { defaultGitLabBaseURI };

package/lib/download/helpers/untar.d.ts

@@ -2,5 +2,4 @@
  * Unpack .tgz archive
  */
 declare function untar(file: string, path: string): Promise<void>;
-
-export { untar };
+export { untar };