@sanity/pkg-utils 3.3.7 → 3.3.9-canary.0

package/dist/_chunks/init-tT7f7xkO.cjs

@@ -0,0 +1,646 @@
+'use strict';
+
+var fs = require('fs/promises');
+var mkdirp = require('mkdirp');
+var path = require('path');
+var prompts = require('prompts');
+var logger = require('./logger-c-JGqYo_.cjs');
+var getLatestVersion = require('get-latest-version');
+var gitUrlParse = require('git-url-parse');
+var outdent = require('outdent');
+var parseGitConfig = require('parse-git-config');
+var prettier = require('prettier');
+require('esbuild-register/dist/node');
+require('pkg-up');
+require('find-config');
+require('fs');
+require('chalk');
+require('zod');
+require('typescript');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var prompts__default = /*#__PURE__*/_interopDefaultCompat(prompts);
+var getLatestVersion__default = /*#__PURE__*/_interopDefaultCompat(getLatestVersion);
+var gitUrlParse__default = /*#__PURE__*/_interopDefaultCompat(gitUrlParse);
+var parseGitConfig__default = /*#__PURE__*/_interopDefaultCompat(parseGitConfig);
+var prettier__default = /*#__PURE__*/_interopDefaultCompat(prettier);
+
+const promptsTypes = {
+  string: "text"
+};
+async function createFromTemplate(options) {
+  const { cwd, logger, packagePath, template: templateOrResolver } = options;
+  const template = typeof templateOrResolver === "function" ? await templateOrResolver({ cwd, logger, packagePath }) : templateOrResolver;
+  logger.log("create new package at", path.relative(cwd, packagePath));
+  const templateOptions = {};
+  for (const templateOption of template.options) {
+    const templateValidate = templateOption.validate;
+    const res = await prompts__default.default(
+      {
+        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];
+  }
+  const features = {};
+  for (const templateFeature of template.features) {
+    const res = templateFeature.optional ? await prompts__default.default(
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `use ${templateFeature.name}?`,
+        initial: templateFeature.initial
+      },
+      { onCancel: () => process.exit(0) }
+    ) : void 0;
+    features[templateFeature.name] = res?.confirm || !templateFeature.optional;
+  }
+  const files = await template.getFiles(templateOptions, features);
+  files.sort((a, b) => {
+    return a.name.localeCompare(b.name);
+  });
+  for (const file of files) {
+    const filePath = path.resolve(packagePath, file.name);
+    await mkdirp.mkdirp(path.dirname(filePath));
+    await fs.writeFile(filePath, file.contents.trim() + "\n");
+    logger.success(`wrote ${path.relative(cwd, filePath)}`);
+  }
+}
+
+function defineTemplateOption(option) {
+  return option;
+}
+
+async function isEmptyDirectory(dirPath) {
+  return (await fs.readdir(dirPath)).length === 0;
+}
+
+const RE_NAME = /^(?:@(?:[a-z0-9-*~][a-z0-9-*._~]*)\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
+const defaultTemplate = async ({ cwd, logger: logger$1, packagePath }) => {
+  const gitConfig = await parseGitConfig__default.default({ cwd, type: "global" });
+  return {
+    options: [
+      defineTemplateOption({
+        name: "repo",
+        type: "string",
+        description: "git url",
+        validate: (v) => {
+          if (!v)
+            return true;
+          try {
+            gitUrlParse__default.default(v);
+            return true;
+          } catch (err) {
+            return "invalid git url";
+          }
+        },
+        parse: (v) => {
+          if (!v)
+            return null;
+          const result = gitUrlParse__default.default(v);
+          return { source: result.source, owner: result.owner, name: result.name };
+        }
+      }),
+      defineTemplateOption({
+        name: "pkgName",
+        type: "string",
+        description: "package name",
+        initial: (options) => options.repo?.name || void 0,
+        validate: (v) => {
+          if (!v)
+            return "package name is required";
+          const match = RE_NAME.exec(v);
+          if (!match) {
+            return "invalid package name";
+          }
+          return true;
+        },
+        parse: (v) => {
+          if (!v) {
+            throw new Error("package name is required");
+          }
+          const match = RE_NAME.exec(v);
+          if (!match) {
+            throw new Error("invalid package name");
+          }
+          const [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?.name
+      }),
+      defineTemplateOption({
+        name: "authorEmail",
+        type: "string",
+        description: "package author email",
+        initial: gitConfig?.user?.email
+      }),
+      defineTemplateOption({
+        name: "license",
+        type: "string",
+        description: "package license",
+        initial: "MIT",
+        validate: (v) => {
+          if (!v)
+            return "license is required";
+          return true;
+        }
+      })
+    ],
+    features: [
+      {
+        name: "eslint",
+        optional: true,
+        initial: true
+      },
+      {
+        name: "prettier",
+        optional: true,
+        initial: true
+      },
+      {
+        name: "typescript",
+        optional: true,
+        initial: true
+      }
+    ],
+    async getFiles(options, features) {
+      const { pkgName, repo } = options;
+      const { fullName: name } = pkgName;
+      const author = [options.authorName, options.authorEmail && `<${options.authorEmail}>`].filter(Boolean).join(" ") ?? void 0;
+      const prettierConfig = features.prettier ? {
+        bracketSpacing: false,
+        plugins: ["prettier-plugin-packagejson"],
+        printWidth: 100,
+        quoteProps: "consistent",
+        semi: false,
+        singleQuote: true,
+        tabWidth: 2,
+        overrides: [
+          {
+            files: ["*.yml"],
+            options: {
+              singleQuote: false
+            }
+          }
+        ]
+      } : void 0;
+      const 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,
+        "type": "module",
+        "exports": {
+          ".": {
+            types: void 0,
+            source: features.typescript ? "./src/index.ts" : "./src/index.js",
+            import: "./dist/index.js",
+            require: "./dist/index.cjs",
+            default: "./dist/index.js"
+          },
+          "./package.json": "./package.json"
+        },
+        "main": "./dist/index.cjs",
+        "module": "./dist/index.js",
+        "source": features.typescript ? "./src/index.ts" : "./src/index.js",
+        "types": void 0,
+        "files": ["dist", "src"],
+        "scripts": {
+          "build": "run-s clean pkg:build pkg:check",
+          "clean": "rimraf dist",
+          "format": features.prettier ? "prettier --write --cache --ignore-unknown ." : void 0,
+          "pkg:build": "pkg build --strict",
+          "pkg:check": "pkg check --strict"
+        },
+        "lint-staged": features.prettier ? {
+          "*": ["prettier --write --cache --ignore-unknown"]
+        } : void 0,
+        // prettier: prettierConfig,
+        "dependencies": {},
+        "devDependencies": {
+          "@sanity/pkg-utils": "*",
+          "@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": "*",
+          "npm-run-all": "*",
+          "prettier": features.prettier ? "*" : void 0,
+          "prettier-plugin-packagejson": features.prettier ? "*" : void 0,
+          "rimraf": "*",
+          "typescript": void 0
+        },
+        "engines": {
+          node: ">=18.0.0"
+        }
+      };
+      const files = [];
+      files.push({
+        name: ".editorconfig",
+        contents: outdent.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.outdent`
+        *.local
+        *.log
+        *.tgz
+
+        .DS_Store
+        dist
+        etc
+        node_modules
+        `
+      });
+      if (features.prettier) {
+        files.push({
+          name: ".prettierignore",
+          contents: outdent.outdent`
+          dist
+          pnpm-lock.yaml
+          `
+        });
+        files.push({
+          name: ".prettierrc",
+          contents: await format(
+            path.resolve(packagePath, ".prettierrc.json"),
+            JSON.stringify(prettierConfig, null, 2) + "\n",
+            prettierConfig
+          )
+        });
+      }
+      if (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`;
+      }
+      if (features.typescript) {
+        pkgJson.types = "./dist/index.d.ts";
+        const mainExport = pkgJson.exports?.["."];
+        if (logger.isRecord(mainExport)) {
+          mainExport.types = "./dist/index.d.ts";
+        }
+        pkgJson.scripts = {
+          ...pkgJson.scripts,
+          ["ts:check"]: "tsc --build"
+        };
+        const devDependencies = pkgJson.devDependencies;
+        if (logger.isRecord(devDependencies)) {
+          devDependencies["typescript"] = "*";
+        }
+      }
+      if (features.eslint) {
+        const eslintConfig = {
+          root: true,
+          env: {
+            browser: true,
+            es6: true,
+            node: true
+          },
+          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.outdent`
+          dist
+          `
+        });
+        pkgJson.scripts = {
+          ...pkgJson.scripts,
+          lint: features.typescript ? "eslint . --ext .cjs,.js,.ts,.tsx" : "eslint . --ext .cjs,.js"
+        };
+        pkgJson.devDependencies = {
+          ...pkgJson.devDependencies,
+          "eslint": "*",
+          "eslint-config-prettier": features.prettier ? "*" : void 0,
+          "eslint-plugin-simple-import-sort": "*",
+          "eslint-plugin-import": "*",
+          "eslint-plugin-prettier": features.prettier ? "*" : void 0
+        };
+        if (features.typescript) {
+          pkgJson.devDependencies = {
+            ...pkgJson.devDependencies,
+            "@typescript-eslint/eslint-plugin": "*",
+            "@typescript-eslint/parser": "*"
+          };
+          const eslintConfigOverride = {
+            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"
+            }
+          };
+          eslintConfig.overrides = [eslintConfigOverride];
+        }
+        files.push({
+          name: ".eslintrc.cjs",
+          contents: await format(
+            path.resolve(packagePath, ".eslintrc.cjs"),
+            outdent.outdent`
+            'use strict'
+
+            /** @type import('eslint').Linter.Config */
+            module.exports = ${JSON.stringify(eslintConfig, null, 2)}
+            `,
+            prettierConfig
+          )
+        });
+      }
+      if (features.typescript) {
+        files.push({
+          name: "tsconfig.settings.json",
+          contents: await format(
+            path.resolve(packagePath, "tsconfig.settings.json"),
+            outdent.outdent`
+            {
+              "compilerOptions": {
+                // Completeness
+                "skipLibCheck": true,
+
+                // Interop constraints
+                "allowSyntheticDefaultImports": true,
+                "esModuleInterop": true,
+
+                // Language and environment
+                "target": "ES2020",
+
+                // Modules
+                "module": "ES2020",
+                "moduleResolution": "Node",
+
+                // Type checking
+                "alwaysStrict": true,
+                "noFallthroughCasesInSwitch": true,
+                "noImplicitAny": true,
+                "noImplicitReturns": true,
+                "noImplicitThis": true,
+                "noUnusedLocals": true,
+                "noUnusedParameters": true,
+                "strict": true,
+                "strictFunctionTypes": true,
+                "strictNullChecks": true,
+                "strictPropertyInitialization": true
+              }
+            }
+            `,
+            prettierConfig
+          )
+        });
+        files.push({
+          name: "tsconfig.dist.json",
+          contents: await format(
+            path.resolve(packagePath, "tsconfig.dist.json"),
+            outdent.outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./src"],
+              "exclude": ["./src/**/*.test.ts"],
+              "compilerOptions": {
+                "rootDir": ".",
+                "outDir": "./dist",
+                "resolveJsonModule": true
+              }
+            }
+            `,
+            prettierConfig
+          )
+        });
+        files.push({
+          name: "tsconfig.json",
+          contents: await format(
+            path.resolve(packagePath, "tsconfig.json"),
+            outdent.outdent`
+            {
+              "extends": "./tsconfig.settings",
+              "include": ["./**/*.cjs", "./**/*.ts", "./**/*.tsx"],
+              "exclude": ["./node_modules"],
+              "compilerOptions": {
+                "rootDir": ".",
+                "outDir": "./dist",
+                "noEmit": true,
+                "allowJs": true,
+                "resolveJsonModule": true,
+              }
+            }
+            `,
+            prettierConfig
+          )
+        });
+      }
+      if (features.typescript) {
+        files.push({
+          name: "package.config.ts",
+          contents: await format(
+            path.resolve(packagePath, "package.config.ts"),
+            outdent.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',
+            })
+            `,
+            prettierConfig
+          )
+        });
+        files.push({
+          name: "src/index.ts",
+          contents: await format(
+            path.resolve(packagePath, "src/index.ts"),
+            outdent.outdent`
+            /** @public */
+            export function main(): void {
+              //
+            }
+            `,
+            prettierConfig
+          )
+        });
+      } else {
+        files.push({
+          name: "package.config.js",
+          contents: await format(
+            path.resolve(packagePath, "package.config.js"),
+            outdent.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',
+                },
+              },
+            })
+            `,
+            prettierConfig
+          )
+        });
+        files.push({
+          name: "src/index.js",
+          contents: await format(
+            path.resolve(packagePath, "src/index.js"),
+            outdent.outdent`
+            /** @public */
+            export function main() {
+              //
+            }
+            `,
+            prettierConfig
+          )
+        });
+      }
+      try {
+        pkgJson.dependencies = await resolveLatestDeps(pkgJson.dependencies ?? {});
+      } catch (error) {
+        logger$1.warn(error instanceof Error ? error.message : error);
+      }
+      try {
+        pkgJson.devDependencies = await resolveLatestDeps(pkgJson.devDependencies ?? {});
+      } catch (error) {
+        logger$1.warn(error instanceof Error ? error.message : error);
+      }
+      files.push({
+        name: "package.json",
+        contents: await format(
+          path.resolve(packagePath, "package.json"),
+          JSON.stringify(pkgJson, null, 2),
+          prettierConfig
+        )
+      });
+      return files;
+    }
+  };
+};
+function format(filepath, input, prettierOptions) {
+  return prettier__default.default.format(input, { ...prettierOptions, plugins: [], filepath });
+}
+async function resolveLatestDeps(deps) {
+  const depsEntries = Object.entries(deps);
+  const latestDeps = {};
+  for (const entry of depsEntries) {
+    const [name, version] = entry;
+    if (version) {
+      const latestVersion = await getLatestVersion__default.default(name, version);
+      latestDeps[name] = latestVersion ? `^${latestVersion}` : version;
+    }
+  }
+  return latestDeps;
+}
+
+async function init(options) {
+  if (!options.cwd) {
+    throw new Error("Missing required option: cwd");
+  }
+  if (!options.path) {
+    throw new Error("Missing required option: path");
+  }
+  const logger$1 = logger.createLogger();
+  const packagePath = path.resolve(options.cwd, options.path);
+  await ensurePackagePath(packagePath);
+  await createFromTemplate({
+    cwd: options.cwd,
+    logger: logger$1,
+    template: defaultTemplate,
+    packagePath
+  });
+}
+async function ensurePackagePath(packagePath) {
+  const exists = logger.fileExists(packagePath);
+  if (!exists) {
+    await mkdirp.mkdirp(packagePath);
+    return;
+  }
+  const dir = (await fs.lstat(packagePath)).isDirectory();
+  if (!dir) {
+    throw new Error("the package path is a file, not a directory");
+  }
+  const empty = await isEmptyDirectory(packagePath);
+  if (!empty) {
+    throw new Error("the package directory is not empty");
+  }
+}
+
+exports.createFromTemplate = createFromTemplate;
+exports.defineTemplateOption = defineTemplateOption;
+exports.init = init;
+//# sourceMappingURL=init-tT7f7xkO.cjs.map