@sanity/pkg-utils 2.2.17 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "2.2.17",
+  "version": "2.3.0",
   "description": "Simple utilities for modern npm packages.",
   "keywords": [
     "sanity-io",
@@ -139,12 +139,18 @@
     "esbuild": "^0.17.19",
     "esbuild-register": "^3.4.2",
     "find-config": "^1.0.0",
+    "get-latest-version": "^5.0.1",
+    "git-url-parse": "^13.1.0",
     "globby": "^11.1.0",
     "jsonc-parser": "^3.2.0",
     "mkdirp": "^3.0.1",
+    "outdent": "^0.8.0",
+    "parse-git-config": "^3.0.0",
     "pkg-up": "^3.1.0",
     "prettier": "^2.8.8",
+    "prettier-plugin-packagejson": "^2.4.3",
     "pretty-bytes": "^5.6.0",
+    "prompts": "^2.4.2",
     "recast": "^0.23.2",
     "rimraf": "^5.0.1",
     "rollup": "^3.23.0",
@@ -162,8 +168,11 @@
     "@types/babel__core": "^7.20.1",
     "@types/cpx": "^1.5.2",
     "@types/find-config": "^1.0.1",
+    "@types/git-url-parse": "^9.0.1",
     "@types/node": "^20.2.5",
+    "@types/parse-git-config": "^3.0.1",
     "@types/prettier": "^2.7.2",
+    "@types/prompts": "^2.4.4",
     "@types/treeify": "^1.0.0",
     "@types/uuid": "^9.0.1",
     "@typescript-eslint/eslint-plugin": "^5.59.7",
@@ -180,7 +189,6 @@
     "lint-staged": "^13.2.2",
     "npm-run-all": "^4.1.5",
     "outdent": "^0.8.0",
-    "prettier-plugin-packagejson": "^2.4.3",
     "rollup-plugin-visualizer": "^5.9.0",
     "semantic-release": "^21.0.2",
     "ts-node": "^10.9.1",

package/src/cli/index.ts

@@ -26,6 +26,14 @@ cli
     return buildAction(options)
   })
 
+cli.command('init [path]', 'Initialize package').action(async (p) => {
+  const {initAction} = await import('./initAction')
+
+  return initAction({
+    path: p,
+  })
+})
+
 cli
   .command('watch', 'Watch package')
   .option('--strict', 'Strict mode')

package/src/cli/initAction.ts

@@ -0,0 +1,13 @@
+import {init} from '../node/init'
+import {handleError} from './handleError'
+
+export async function initAction(options: {path: string}): Promise<void> {
+  try {
+    await init({
+      cwd: process.cwd(),
+      path: options.path,
+    })
+  } catch (err) {
+    handleError(err)
+  }
+}

package/src/node/core/index.ts

@@ -3,4 +3,5 @@ export * from './contexts'
 export * from './defaults'
 export * from './isRecord'
 export * from './pkg'
+export * from './template'
 export * from './ts'

package/src/node/core/pkg/types.ts

@@ -3,7 +3,10 @@ export interface PackageJSON {
   type?: 'commonjs' | 'module'
   version: string
   private?: boolean
+  author?: string | {name: string; email?: string; url?: string}
   name: string
+  description?: string
+  keywords?: string[]
   bin?: Record<string, string>
   dependencies?: Record<string, string>
   devDependencies?: Record<string, string>
@@ -34,5 +37,15 @@ export interface PackageJSON {
   source?: string
   module?: string
   types?: string
+  files?: string[]
+  scripts?: Record<string, string>
   browserslist?: string[]
+  engines?: {
+    node?: string
+    npm?: string
+  }
+  repository?: string | {type: 'git'; url: string}
+  bugs?: string | {url: string; email?: string}
+  homepage?: string
+  license?: string
 }

package/src/node/core/template/createFromTemplate.ts

@@ -0,0 +1,85 @@
+import {writeFile} from 'fs/promises'
+import {mkdirp} from 'mkdirp'
+import {dirname, relative, resolve} from 'path'
+import prompts from 'prompts'
+
+import {Logger} from '../../logger'
+import {PkgTemplate} from './types'
+
+const promptsTypes = {
+  string: 'text' as const,
+}
+
+/** @internal */
+export async function createFromTemplate(options: {
+  cwd: string
+  logger: Logger
+  packagePath: string
+  template: PkgTemplate
+}): Promise<void> {
+  const {cwd, logger, packagePath, template: templateOrResolver} = options
+
+  const template =
+    typeof templateOrResolver === 'function'
+      ? await templateOrResolver({cwd, logger, packagePath})
+      : templateOrResolver
+
+  logger.log('create new package at', relative(cwd, packagePath))
+
+  const templateOptions: Record<string, string> = {}
+
+  for (const templateOption of template.options) {
+    const templateValidate = templateOption.validate
+
+    const res = await prompts(
+      {
+        type: promptsTypes[templateOption.type],
+        name: templateOption.name,
+        message: templateOption.description,
+        validate: templateValidate ? (prev) => templateValidate(prev) : undefined,
+        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: Record<string, boolean> = {}
+
+  for (const templateFeature of template.features) {
+    const res = templateFeature.optional
+      ? await prompts(
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: `use ${templateFeature.name}?`,
+            initial: templateFeature.initial,
+          },
+          {onCancel: () => process.exit(0)}
+        )
+      : undefined
+
+    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 = resolve(packagePath, file.name)
+
+    await mkdirp(dirname(filePath))
+    await writeFile(filePath, file.contents.trim() + '\n')
+
+    logger.success(`wrote ${relative(cwd, filePath)}`)
+  }
+}

package/src/node/core/template/define.ts

@@ -0,0 +1,6 @@
+import {PkgTemplateOption} from './types'
+
+/** @public */
+export function defineTemplateOption<T>(option: PkgTemplateOption<T>): PkgTemplateOption<T> {
+  return option
+}

package/src/node/core/template/index.ts

@@ -0,0 +1,3 @@
+export * from './createFromTemplate'
+export * from './define'
+export * from './types'

package/src/node/core/template/types.ts

@@ -0,0 +1,45 @@
+import {Logger} from '../../logger'
+
+/** @public */
+export interface PkgTemplateFile {
+  name: string
+  contents: string
+}
+
+/** @public */
+export interface PkgTemplateStringOption<T = string> {
+  name: string
+  type: 'string'
+  description: string
+  initial?: T | ((options: Record<string, any>) => T)
+  parse?: (v: string) => T | null
+  validate?: (v: string) => string | true
+}
+
+/** @public */
+export type PkgTemplateOption<T = string> = PkgTemplateStringOption<T>
+
+/** @public */
+export interface PkgTemplateDefinition {
+  options: PkgTemplateStringOption<any>[]
+  features: {
+    name: string
+    optional: boolean
+    initial: boolean
+  }[]
+  getFiles: (
+    options: Record<string, any>,
+    features: Record<string, boolean>
+  ) => Promise<PkgTemplateFile[]>
+}
+
+/** @public */
+export type PkgTemplateResolver = (options: {
+  cwd: string
+  /** @internal */
+  logger: Logger
+  packagePath: string
+}) => PkgTemplateDefinition | Promise<PkgTemplateDefinition>
+
+/** @public */
+export type PkgTemplate = PkgTemplateDefinition | PkgTemplateResolver

package/src/node/index.ts

@@ -1,6 +1,7 @@
 export * from './build'
 export * from './check'
 export * from './core'
+export * from './init'
 export * from './logger'
 export * from './resolveBuildTasks'
 export * from './tasks'

package/src/node/init.ts

@@ -0,0 +1,55 @@
+import {lstat} from 'fs/promises'
+import {mkdirp} from 'mkdirp'
+import {resolve} from 'path'
+
+import {createFromTemplate} from './core/template'
+import {fileExists} from './fileExists'
+import {isEmptyDirectory} from './isEmptyDirectory'
+import {createLogger} from './logger'
+import {defaultTemplate} from './templates'
+
+/** @public */
+export async function init(options: {cwd: string; path: string}): Promise<void> {
+  if (!options.cwd) {
+    throw new Error('Missing required option: cwd')
+  }
+
+  if (!options.path) {
+    throw new Error('Missing required option: path')
+  }
+
+  const logger = createLogger()
+
+  const packagePath = resolve(options.cwd, options.path)
+
+  await ensurePackagePath(packagePath)
+
+  await createFromTemplate({
+    cwd: options.cwd,
+    logger,
+    template: defaultTemplate,
+    packagePath,
+  })
+}
+
+async function ensurePackagePath(packagePath: string): Promise<void> {
+  const exists = fileExists(packagePath)
+
+  if (!exists) {
+    await mkdirp(packagePath)
+
+    return
+  }
+
+  const dir = (await 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')
+  }
+}

package/src/node/isEmptyDirectory.ts

@@ -0,0 +1,5 @@
+import {readdir} from 'fs/promises'
+
+export async function isEmptyDirectory(dirPath: string): Promise<boolean> {
+  return (await readdir(dirPath)).length === 0
+}

package/src/node/templates/default/index.ts

@@ -0,0 +1 @@
+export * from './template'