@sanity/pkg-utils 11.0.17 → 12.0.1

package/dist/initAction-CmOO8eod.js

@@ -0,0 +1,618 @@
+import { i as fileExists, n as createLogger, r as isRecord, t as handleError } from "./handleError-83GwKIFM.js";
+import { createRequire } from "node:module";
+import { dirname, relative, resolve } from "node:path";
+import { lstat, readdir, writeFile } from "node:fs/promises";
+import { mkdirp } from "mkdirp";
+import prompts from "prompts";
+import { execSync } from "node:child_process";
+import { getLatestVersion } from "get-latest-version";
+import { outdent } from "outdent";
+import { format } from "prettier";
+var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports), __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: !0
+	});
+	return no_symbols || __defProp(target, Symbol.toStringTag, { value: "Module" }), target;
+}, __copyProps = (to, from, except, desc) => {
+	if (from && typeof from == "object" || typeof from == "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) key = keys[i], !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+		get: ((k) => from[k]).bind(null, key),
+		enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+	});
+	return to;
+}, __toESM = (mod, isNodeMode, target) => (target = mod == null ? {} : __create(__getProtoOf(mod)), __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: !0
+}) : target, mod)), __require = /* @__PURE__ */ createRequire(import.meta.url);
+const promptsTypes = { string: "text" };
+/** @internal */
+async function createFromTemplate(options) {
+	let { cwd, logger, packagePath, template: templateOrResolver } = options, template = typeof templateOrResolver == "function" ? await templateOrResolver({
+		cwd,
+		logger,
+		packagePath
+	}) : templateOrResolver;
+	logger.log("create new package at", relative(cwd, packagePath));
+	let templateOptions = {};
+	for (let templateOption of template.options) {
+		let templateValidate = templateOption.validate, res = await prompts({
+			type: promptsTypes[templateOption.type],
+			name: templateOption.name,
+			message: templateOption.description,
+			validate: templateValidate ? (prev) => templateValidate(prev) : void 0,
+			initial: typeof templateOption.initial == "function" ? templateOption.initial(templateOptions) : templateOption.initial
+		}, { onCancel: () => process.exit(0) });
+		templateOptions[templateOption.name] = templateOption.parse ? templateOption.parse(res[templateOption.name]) : res[templateOption.name];
+	}
+	let features = {};
+	for (let templateFeature of template.features) {
+		let res = templateFeature.optional ? await prompts({
+			type: "confirm",
+			name: "confirm",
+			message: `use ${templateFeature.name}?`,
+			initial: templateFeature.initial
+		}, { onCancel: () => process.exit(0) }) : void 0;
+		features[templateFeature.name] = res?.confirm || !templateFeature.optional;
+	}
+	let files = await template.getFiles(templateOptions, features);
+	files.sort((a, b) => a.name.localeCompare(b.name));
+	for (let file of files) {
+		let filePath = resolve(packagePath, file.name);
+		await mkdirp(dirname(filePath)), await writeFile(filePath, file.contents.trim() + "\n"), logger.success(`wrote ${relative(cwd, filePath)}`);
+	}
+}
+/** @public */
+function defineTemplateOption(option) {
+	return option;
+}
+async function isEmptyDirectory(dirPath) {
+	return (await readdir(dirPath)).length === 0;
+}
+const overridableDefaults = {
+	endOfLine: "lf",
+	tabWidth: 2,
+	useTabs: !1
+}, json5 = {
+	files: ["*.json5"],
+	options: {
+		quoteProps: "preserve",
+		singleQuote: !1
+	}
+}, yaml = {
+	files: ["*.yml"],
+	options: { singleQuote: !1 }
+}, config = {
+	...overridableDefaults,
+	printWidth: 100,
+	semi: !1,
+	singleQuote: !0,
+	quoteProps: "consistent",
+	bracketSpacing: !1,
+	plugins: ["prettier-plugin-packagejson"],
+	overrides: [json5, yaml]
+};
+var require_parse_url = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var urlModule = __require("url"), URLCtor = typeof URL > "u" ? urlModule.URL || null : URL, legacyURLParse = URLCtor ? null : urlModule.parse;
+	function parseWHATWG(str) {
+		try {
+			var u = new URLCtor(str), auth = null;
+			u.username && (auth = u.password ? u.username + ":" + u.password : u.username);
+			var host = u.host || null, hostname = u.hostname || null, pathname = u.pathname || null, path = u.pathname + (u.search || "") || null;
+			if (!host && pathname && str.indexOf("//") === -1) {
+				var slashIdx = pathname.indexOf("/");
+				slashIdx === -1 ? (host = pathname, hostname = pathname, pathname = null, path = null) : (host = pathname.slice(0, slashIdx), hostname = host, pathname = pathname.slice(slashIdx), path = pathname + (u.search || ""));
+			}
+			return {
+				auth,
+				hash: u.hash || null,
+				host,
+				hostname,
+				href: u.href,
+				path,
+				pathname,
+				port: u.port || null,
+				protocol: u.protocol || null,
+				query: u.search ? u.search.slice(1) : null,
+				search: u.search || null,
+				slashes: str.indexOf("//") !== -1 || null
+			};
+		} catch {
+			var hashIdx = str.indexOf("#"), hash = hashIdx === -1 ? null : str.slice(hashIdx), pathPart = hashIdx === -1 ? str : str.slice(0, hashIdx), queryIdx = pathPart.indexOf("?"), search = queryIdx === -1 ? null : pathPart.slice(queryIdx), pathnamePart = queryIdx === -1 ? pathPart : pathPart.slice(0, queryIdx);
+			return {
+				auth: null,
+				hash,
+				host: null,
+				hostname: null,
+				href: str,
+				path: pathPart || null,
+				pathname: pathnamePart || null,
+				port: null,
+				protocol: null,
+				query: search ? search.slice(1) : null,
+				search,
+				slashes: null
+			};
+		}
+	}
+	module.exports = URLCtor ? parseWHATWG : legacyURLParse;
+})), import_parse_github_url = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*!
+	* parse-github-url <https://github.com/jonschlinkert/parse-github-url>
+	*
+	* Copyright (c) 2015-2017, Jon Schlinkert.
+	* Released under the MIT License.
+	*/
+	var parseURL = require_parse_url(), cache = { __proto__: null };
+	function isChecksum(str) {
+		return /^[a-f0-9]{40}$/i.test(str);
+	}
+	function getBranch(str, obj) {
+		var segs = str.split("#"), branch;
+		return segs.length > 1 && (branch = segs[segs.length - 1]), !branch && obj.hash && obj.hash.charAt(0) === "#" && (branch = obj.hash.slice(1)), branch || "master";
+	}
+	function trimSlash(path) {
+		return path.charAt(0) === "/" ? path.slice(1) : path;
+	}
+	function name(str) {
+		return str ? str.replace(/\.git$/, "") : null;
+	}
+	function owner(str) {
+		if (!str) return null;
+		var idx = str.indexOf(":");
+		return idx > -1 ? str.slice(idx + 1) : str;
+	}
+	/**
+	* Extract the host from a git@ URL using the WHATWG URL API.
+	*/
+	function getGitAtHost(str) {
+		return parseURL("http://" + str.replace(/git@([^:]+):/, "$1/")).host || null;
+	}
+	function parse(str) {
+		if (typeof str != "string" || !str.length || str.indexOf("git@gist") !== -1 || str.indexOf("//gist") !== -1) return null;
+		var obj = parseURL(str);
+		if (typeof obj.path != "string" || !obj.path.length || typeof obj.pathname != "string" || !obj.pathname.length) return null;
+		!obj.host && /^git@/.test(str) === !0 && (obj.host = getGitAtHost(str)), obj.path = trimSlash(obj.path), obj.pathname = trimSlash(obj.pathname), obj.filepath = null, obj.path.indexOf("repos") === 0 && (obj.path = obj.path.slice(6));
+		var seg = obj.path.split("/").filter(Boolean), hasBlob = seg[2] === "blob";
+		hasBlob && !isChecksum(seg[3]) && (obj.branch = seg[3], seg.length > 4 && (obj.filepath = seg.slice(4).join("/")));
+		var blob = str.indexOf("blob");
+		hasBlob && blob !== -1 && (obj.blob = str.slice(blob + 5));
+		var hasTree = seg[2] === "tree", tree = str.indexOf("tree");
+		if (hasTree && tree !== -1) {
+			var idx = tree + 5, branch = str.slice(idx), slash = branch.indexOf("/");
+			slash !== -1 && (branch = branch.slice(0, slash)), obj.branch = branch;
+		}
+		if (obj.owner = owner(seg[0]), obj.name = name(seg[1]), seg.length > 1 && obj.owner && obj.name) obj.repo = obj.owner + "/" + obj.name;
+		else {
+			var href = obj.href.split(":");
+			if (href.length === 2 && obj.href.indexOf("//") === -1) {
+				obj.repo = obj.repo || href[href.length - 1];
+				var repoSegments = obj.repo.split("/");
+				obj.owner = repoSegments[0], obj.name = repoSegments[1];
+			} else {
+				var match = obj.href.match(/\/([^/]*)$/);
+				obj.owner = match ? match[1] : null, obj.repo = null;
+			}
+			if (obj.repo && (!obj.owner || !obj.name)) {
+				var segs = obj.repo.split("/");
+				segs.length === 2 && (obj.owner = segs[0], obj.name = segs[1]);
+			}
+		}
+		return obj.branch || (obj.branch = seg[2] || getBranch(obj.path, obj), seg.length > 3 && (obj.filepath = seg.slice(3).join("/"))), obj.host = obj.host || "github.com", obj.owner = obj.owner || null, obj.name = obj.name || null, obj.repository = obj.repo, obj;
+	}
+	module.exports = function parseGithubUrl(str) {
+		return cache[str] || (cache[str] = parse(str)), cache[str];
+	};
+})))(), 1);
+const RE_NAME = /^(?:@(?:[a-z0-9-*~][a-z0-9-*._~]*)\/)?[a-z0-9-~][a-z0-9-._~]*$/i, defaultTemplate = async ({ cwd, logger, packagePath }) => {
+	let gitConfig = getGitUserConfig(cwd);
+	return {
+		options: [
+			defineTemplateOption({
+				name: "repo",
+				type: "string",
+				description: "git url",
+				validate: (v) => {
+					if (!v) return !0;
+					let result = (0, import_parse_github_url.default)(v);
+					return !result?.host || !result.owner || !result.name ? "invalid git url" : !0;
+				},
+				parse: (v) => {
+					if (!v) return null;
+					let result = (0, import_parse_github_url.default)(v);
+					if (!result?.host || !result.owner || !result.name) throw Error("invalid git url");
+					return {
+						source: result.host,
+						owner: result.owner,
+						name: result.name
+					};
+				}
+			}),
+			defineTemplateOption({
+				name: "pkgName",
+				type: "string",
+				description: "package name",
+				initial: (options) => options.repo?.name || void 0,
+				validate: (v) => v ? RE_NAME.exec(v) ? !0 : "invalid package name" : "package name is required",
+				parse: (v) => {
+					if (!v) throw Error("package name is required");
+					if (!RE_NAME.exec(v)) throw Error("invalid package name");
+					let [scope, name] = v.split("/");
+					return {
+						scope,
+						name,
+						fullName: v
+					};
+				}
+			}),
+			defineTemplateOption({
+				name: "description",
+				type: "string",
+				description: "package description"
+			}),
+			defineTemplateOption({
+				name: "authorName",
+				type: "string",
+				description: "package author name",
+				initial: gitConfig.user
+			}),
+			defineTemplateOption({
+				name: "authorEmail",
+				type: "string",
+				description: "package author email",
+				initial: gitConfig.email
+			}),
+			defineTemplateOption({
+				name: "license",
+				type: "string",
+				description: "package license",
+				initial: "MIT",
+				validate: (v) => v ? !0 : "license is required"
+			})
+		],
+		features: [
+			{
+				name: "eslint",
+				optional: !0,
+				initial: !0
+			},
+			{
+				name: "prettier",
+				optional: !0,
+				initial: !0
+			},
+			{
+				name: "typescript",
+				optional: !0,
+				initial: !0
+			}
+		],
+		async getFiles(options, features) {
+			let { pkgName, repo } = options, { fullName: name } = pkgName, author = [options.authorName, options.authorEmail && `<${options.authorEmail}>`].filter(Boolean).join(" ") ?? void 0, pkgJson = {
+				name,
+				version: "0.0.0",
+				description: options.description ?? void 0,
+				keywords: [],
+				homepage: void 0,
+				bugs: void 0,
+				repository: void 0,
+				license: options.license,
+				author,
+				sideEffects: !1,
+				type: "module",
+				exports: {
+					".": {
+						source: features.typescript ? "./src/index.ts" : "./src/index.js",
+						require: "./dist/index.cjs",
+						default: "./dist/index.js"
+					},
+					"./package.json": "./package.json"
+				},
+				main: "./dist/index.cjs",
+				module: "./dist/index.js",
+				types: void 0,
+				files: ["dist", "src"],
+				scripts: {
+					build: "pkg build --strict --clean --check",
+					format: features.prettier ? "prettier --write --cache --ignore-unknown ." : void 0
+				},
+				"lint-staged": features.prettier ? { "*": ["prettier --write --cache --ignore-unknown"] } : void 0,
+				browserslist: "extends @sanity/browserslist-config",
+				prettier: features.prettier ? "@sanity/prettier-config" : void 0,
+				dependencies: {},
+				devDependencies: {
+					"@sanity/tsconfig": features.typescript ? "^1" : void 0,
+					"@sanity/pkg-utils": "^9",
+					"@sanity/prettier-config": features.prettier ? "^1" : void 0,
+					"@typescript-eslint/eslint-plugin": void 0,
+					"@typescript-eslint/parser": void 0,
+					eslint: void 0,
+					"eslint-config-prettier": void 0,
+					"eslint-plugin-import": void 0,
+					"eslint-plugin-prettier": void 0,
+					"eslint-plugin-simple-import-sort": void 0,
+					"lint-staged": "^15",
+					prettier: features.prettier ? "^3" : void 0,
+					typescript: void 0
+				},
+				engines: { node: ">=20.19 <22 || >=22.12" }
+			}, files = [];
+			if (files.push({
+				name: ".editorconfig",
+				contents: outdent`
+        root = true
+
+        [*]
+        charset = utf-8
+        indent_style = space
+        indent_size = 2
+        end_of_line = lf
+        insert_final_newline = true
+        trim_trailing_whitespace = true
+        `
+			}), files.push({
+				name: ".gitignore",
+				contents: outdent`
+        *.local
+        *.log
+        *.tgz
+
+        .DS_Store
+        dist
+        etc
+        node_modules
+        `
+			}), features.prettier && files.push({
+				name: ".prettierignore",
+				contents: outdent`
+          dist
+          pnpm-lock.yaml
+          `
+			}), repo && (pkgJson.repository = {
+				type: "git",
+				url: `git+ssh://git@${repo.source}/${repo.owner}/${repo.name}.git`
+			}, pkgJson.bugs = { url: `https://${repo.source}/${repo.owner}/${repo.name}/issues` }, pkgJson.homepage = `https://${repo.source}/${repo.owner}/${repo.name}#readme`), features.typescript) {
+				pkgJson.types = "./dist/index.d.ts", pkgJson.scripts = {
+					...pkgJson.scripts,
+					"ts:check": "tsc --noEmit"
+				};
+				let devDependencies = pkgJson.devDependencies;
+				isRecord(devDependencies) && (devDependencies.typescript = "^5.9");
+			}
+			if (features.eslint) {
+				let eslintConfig = {
+					root: !0,
+					env: {
+						browser: !0,
+						es6: !0,
+						node: !0
+					},
+					extends: ["eslint:recommended", features.prettier ? "plugin:prettier/recommended" : void 0].filter(Boolean),
+					parserOptions: {
+						ecmaVersion: 2020,
+						sourceType: "module"
+					},
+					plugins: [
+						"import",
+						"simple-import-sort",
+						features.prettier ? "prettier" : void 0
+					].filter(Boolean),
+					rules: {
+						"no-console": "error",
+						"no-shadow": "error",
+						"no-warning-comments": ["warn", {
+							location: "start",
+							terms: ["todo", "fixme"]
+						}],
+						"quote-props": ["warn", "consistent-as-needed"],
+						"simple-import-sort/exports": "warn",
+						"simple-import-sort/imports": "warn",
+						strict: ["warn", "global"]
+					}
+				};
+				files.push({
+					name: ".eslintignore",
+					contents: outdent`
+          dist
+          `
+				}), pkgJson.scripts = {
+					...pkgJson.scripts,
+					lint: features.typescript ? "eslint . --ext .cjs,.js,.ts,.tsx" : "eslint . --ext .cjs,.js"
+				}, pkgJson.devDependencies = {
+					...pkgJson.devDependencies,
+					eslint: "^8",
+					"eslint-config-prettier": features.prettier ? "^9" : void 0,
+					"eslint-plugin-import": "^2",
+					"eslint-plugin-prettier": features.prettier ? "^5" : void 0,
+					"eslint-plugin-simple-import-sort": "^12"
+				}, features.typescript && (pkgJson.devDependencies = {
+					...pkgJson.devDependencies,
+					"@typescript-eslint/eslint-plugin": "^7",
+					"@typescript-eslint/parser": "^7"
+				}, eslintConfig.overrides = [{
+					files: ["**/*.ts", "**/*.tsx"],
+					parser: "@typescript-eslint/parser",
+					parserOptions: { project: ["./tsconfig.json"] },
+					extends: [
+						"eslint:recommended",
+						features.prettier ? "plugin:prettier/recommended" : void 0,
+						"plugin:@typescript-eslint/eslint-recommended",
+						"plugin:@typescript-eslint/recommended"
+					].filter(Boolean),
+					plugins: [
+						"import",
+						"@typescript-eslint",
+						"simple-import-sort",
+						features.prettier ? "prettier" : void 0
+					].filter(Boolean),
+					rules: {
+						"@typescript-eslint/explicit-module-boundary-types": "error",
+						"@typescript-eslint/interface-name-prefix": "off",
+						"@typescript-eslint/member-delimiter-style": "off",
+						"@typescript-eslint/no-empty-interface": "off"
+					}
+				}]), files.push({
+					name: ".eslintrc.cjs",
+					contents: await prettierFormat(resolve(packagePath, ".eslintrc.cjs"), outdent`
+            'use strict'
+
+            /** @type import('eslint').Linter.Config */
+            module.exports = ${JSON.stringify(eslintConfig, null, 2)}
+            `, config)
+				});
+			}
+			features.typescript && (files.push({
+				name: "tsconfig.settings.json",
+				contents: await prettierFormat(resolve(packagePath, "tsconfig.settings.json"), outdent`
+            {
+              "extends": "@sanity/tsconfig/strictest",
+              "compilerOptions": {
+                "rootDir": ".",
+                "outDir": "./dist"
+              }
+            }
+            `, config)
+			}), files.push({
+				name: "tsconfig.dist.json",
+				contents: await prettierFormat(resolve(packagePath, "tsconfig.dist.json"), outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./src"],
+              "exclude": ["./src/**/*.test.ts"]
+            }
+            `, config)
+			}), files.push({
+				name: "tsconfig.json",
+				contents: await prettierFormat(resolve(packagePath, "tsconfig.json"), outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./**/*.cjs", "./**/*.ts", "./**/*.tsx"],
+              "exclude": ["./node_modules"]
+            }
+            `, config)
+			})), features.typescript ? (files.push({
+				name: "package.config.ts",
+				contents: await prettierFormat(resolve(packagePath, "package.config.ts"), outdent`
+            import {defineConfig} from '@sanity/pkg-utils'
+
+            // https://github.com/sanity-io/pkg-utils#configuration
+            export default defineConfig({
+              // the path to the tsconfig file for distributed builds
+              tsconfig: 'tsconfig.dist.json',
+            })
+            `, config)
+			}), files.push({
+				name: "src/index.ts",
+				contents: await prettierFormat(resolve(packagePath, "src/index.ts"), outdent`
+            /** @public */
+            export function main(): void {
+              //
+            }
+            `, config)
+			})) : (files.push({
+				name: "package.config.js",
+				contents: await prettierFormat(resolve(packagePath, "package.config.js"), outdent`
+            import {defineConfig} from '@sanity/pkg-utils'
+
+            export default defineConfig({
+              extract: {
+                rules: {
+                  // do not require internal members to be prefixed with \`_\`
+                  'ae-internal-missing-underscore': 'off',
+                },
+              },
+            })
+            `, config)
+			}), files.push({
+				name: "src/index.js",
+				contents: await prettierFormat(resolve(packagePath, "src/index.js"), outdent`
+            /** @public */
+            export function main() {
+              //
+            }
+            `, config)
+			}));
+			try {
+				pkgJson.dependencies = await resolveLatestDeps(pkgJson.dependencies ?? {});
+			} catch (error) {
+				logger.warn(error instanceof Error ? error.message : error);
+			}
+			try {
+				pkgJson.devDependencies = await resolveLatestDeps(pkgJson.devDependencies ?? {});
+			} catch (error) {
+				logger.warn(error instanceof Error ? error.message : error);
+			}
+			return files.push({
+				name: "package.json",
+				contents: await prettierFormat(resolve(packagePath, "package.json"), JSON.stringify(pkgJson, null, 2), config)
+			}), files;
+		}
+	};
+};
+function prettierFormat(filepath, input, prettierOptions) {
+	return format(input, {
+		...prettierOptions,
+		plugins: [],
+		filepath
+	});
+}
+async function resolveLatestDeps(deps) {
+	let depsEntries = Object.entries(deps), latestDeps = {};
+	for (let entry of depsEntries) {
+		let [name, version] = entry;
+		if (version) {
+			let latestVersion = await getLatestVersion(name, { range: version });
+			latestDeps[name] = latestVersion ? `^${latestVersion}` : version;
+		}
+	}
+	return latestDeps;
+}
+function getGitUserConfig(cwd) {
+	let user, email;
+	try {
+		user = execSync("git config user.name", {
+			encoding: "utf8",
+			cwd
+		}).trim() || void 0, email = execSync("git config user.email", {
+			encoding: "utf8",
+			cwd
+		}).trim() || void 0;
+	} catch {}
+	return {
+		user,
+		email
+	};
+}
+/** @public */
+async function init(options) {
+	if (!options.cwd) throw Error("Missing required option: cwd");
+	if (!options.path) throw Error("Missing required option: path");
+	let logger = createLogger(), packagePath = resolve(options.cwd, options.path);
+	await ensurePackagePath(packagePath), await createFromTemplate({
+		cwd: options.cwd,
+		logger,
+		template: defaultTemplate,
+		packagePath
+	});
+}
+async function ensurePackagePath(packagePath) {
+	if (!fileExists(packagePath)) {
+		await mkdirp(packagePath);
+		return;
+	}
+	if (!(await lstat(packagePath)).isDirectory()) throw Error("the package path is a file, not a directory");
+	if (!await isEmptyDirectory(packagePath)) throw Error("the package directory is not empty");
+}
+async function initAction(options) {
+	try {
+		await init({
+			cwd: process.cwd(),
+			path: options.path
+		});
+	} catch (err) {
+		handleError(err);
+	}
+}
+export { initAction, __exportAll as t };
+
+//# sourceMappingURL=initAction-CmOO8eod.js.map