package npmpackage

import (
	"strings"
	"net"
	"list"
	"cue.dev/x/npmjs/eslint"
	"cue.dev/x/npmjs/prettier"
	"cue.dev/x/npmjs/stylelint"
	"cue.dev/x/npmjs/ava"
	"cue.dev/x/semanticrelease"
	"cue.dev/x/npmjs/jscpd"
	"cue.dev/x/npmjs/madge"
	"cue.dev/x/npmjs/nodemon"
	"cue.dev/x/npmjs/quikrun"
)

// JSON schema for NPM package.json files
#Schema: {
	@jsonschema(schema="http://json-schema.org/draft-07/schema#")
	_schema
	_schema: {
		@jsonschema(id="https://json.schemastore.org/package.json")
		{[=~"^_"]: _}

		// The name of the package.
		"name"?: strings.MaxRunes(214) & strings.MinRunes(1)

		// Version must be parsable by node-semver, which is bundled with npm as a dependency.
		"version"?: string

		// This helps people discover your package, as it's listed in 'npm search'.
		"description"?: string

		// This helps people discover your package as it's listed in 'npm search'.
		"keywords"?: [...string]

		// The url to the project homepage.
		"homepage"?: string

		// The url to your project's issue tracker and / or the email address to which
		// issues should be reported. These are helpful for people who encounter issues
		// with your package.
		"bugs"?: string | {
			// The url to your project's issue tracker.
			"url"?: net.AbsURL

			// The email address to which issues should be reported.
			"email"?: string
			...
		}
		"license"?: #license

		// DEPRECATED: Instead, use SPDX expressions, like this: { "license": "ISC" } or
		// { "license": "(MIT OR Apache-2.0)" } see:
		// 'https://docs.npmjs.com/files/package.json#license'.
		"licenses"?: [...{
			"type"?: #license
			"url"?:  net.AbsURL
			...
		}]
		"author"?: #person

		// A list of people who contributed to this package.
		"contributors"?: [...#person]

		// A list of people who maintains this package.
		"maintainers"?: [...#person]

		// The 'files' field is an array of files to include in your project. If you
		// name a folder in the array, then it will also include the files inside that
		// folder.
		"files"?: [...string]

		// The main field is a module ID that is the primary entry point to your program.
		"main"?: string

		// The "exports" field is used to restrict external access to non-exported
		// module files, also enables a module to import itself using "name".
		"exports"?: matchN(1, [
			#packageExportsEntryPath,
			close({
				"."?: #packageExportsEntryOrFallback

				{[=~"^\\./.+"]: #packageExportsEntryOrFallback}
			}),
			#packageExportsEntryObject,
			#packageExportsFallback
		])

		// The "imports" field is used to create private mappings that only apply to
		// import specifiers from within the package itself.
		"imports"?: close({

			{[=~"^#.+$"]: #packageImportsEntryOrFallback}})
		"bin"?: string | {[string]: string}

		// When set to "module", the type field allows a package to specify all .js
		// files within are ES modules. If the "type" field is omitted or set to
		// "commonjs", all .js files are treated as CommonJS.
		"type"?: "commonjs" | "module"

		// Set the types property to point to your bundled declaration file.
		"types"?: string

		// Note that the "typings" field is synonymous with "types", and could be used as well.
		"typings"?: string

		// The "typesVersions" field is used since TypeScript 3.1 to support features
		// that were only made available in newer TypeScript versions.
		"typesVersions"?: [string]: close({
			// Maps all file paths to the file paths specified in the array.
			"*"?: [...=~"^[^*]*(?:\\*[^*]*)?$"]

			{[=~"^[^*]+$"]: [...string]}

			{[=~"^[^*]*\\*[^*]*$"]: [...=~"^[^*]*(?:\\*[^*]*)?$"]}
		})

		// Specify either a single file or an array of filenames to put in place for the
		// man program to find.
		"man"?: string | [...string]
		"directories"?: {
			// If you specify a 'bin' directory, then all the files in that folder will be
			// used as the 'bin' hash.
			"bin"?: string

			// Put markdown files in here. Eventually, these will be displayed nicely, maybe, someday.
			"doc"?: string

			// Put example scripts in here. Someday, it might be exposed in some clever way.
			"example"?: string

			// Tell people where the bulk of your library is. Nothing special is done with
			// the lib folder in any way, but it's useful meta info.
			"lib"?: string

			// A folder that is full of man pages. Sugar to generate a 'man' array by walking the folder.
			"man"?:  string
			"test"?: string
			...
		}

		// Specify the place where your code lives. This is helpful for people who want to contribute.
		"repository"?: string | {
			"type"?:      string
			"url"?:       string
			"directory"?: string
			...
		}
		"funding"?: matchN(1, [
			#fundingUrl,
			#fundingWay,
			list.MinItems(1) & list.UniqueItems() & [...matchN(1, [#fundingUrl, #fundingWay])]
		])

		// The 'scripts' member is an object hash of script commands that are run at
		// various times in the lifecycle of your package. The key is the lifecycle
		// event, and the value is the command to run at that point.
		"scripts"?: {
			// Run code quality tools, e.g. ESLint, TSLint, etc.
			"lint"?: string

			// Run BEFORE the package is published (Also run on local npm install without any arguments).
			"prepublish"?: string

			// Runs BEFORE the package is packed, i.e. during "npm publish" and "npm pack",
			// and on local "npm install" without any arguments. This is run AFTER
			// "prepublish", but BEFORE "prepublishOnly".
			"prepare"?: string

			// Run BEFORE the package is prepared and packed, ONLY on npm publish.
			"prepublishOnly"?: string

			// run BEFORE a tarball is packed (on npm pack, npm publish, and when installing git dependencies).
			"prepack"?: string

			// Run AFTER the tarball has been generated and moved to its final destination.
			"postpack"?: string

			// Publishes a package to the registry so that it can be installed by name. See
			// https://docs.npmjs.com/cli/v8/commands/npm-publish
			"publish"?:     string
			"postpublish"?: #scriptsPublishAfter

			// Run BEFORE the package is installed.
			"preinstall"?:   string
			"install"?:      #scriptsInstallAfter
			"postinstall"?:  #scriptsInstallAfter
			"preuninstall"?: #scriptsUninstallBefore
			"uninstall"?:    #scriptsUninstallBefore

			// Run AFTER the package is uninstalled.
			"postuninstall"?: string
			"preversion"?:    #scriptsVersionBefore
			"version"?:       #scriptsVersionBefore

			// Run AFTER bump the package version.
			"postversion"?: string
			"pretest"?:     #scriptsTest
			"test"?:        #scriptsTest
			"posttest"?:    #scriptsTest
			"prestop"?:     #scriptsStop
			"stop"?:        #scriptsStop
			"poststop"?:    #scriptsStop
			"prestart"?:    #scriptsStart
			"start"?:       #scriptsStart
			"poststart"?:   #scriptsStart
			"prerestart"?:  #scriptsRestart
			"restart"?:     #scriptsRestart
			"postrestart"?: #scriptsRestart

			// Start dev server to serve application files
			"serve"?: string
			{[!~"^(lint|prepublish|prepare|prepublishOnly|prepack|postpack|publish|postpublish|preinstall|install|postinstall|preuninstall|uninstall|postuninstall|preversion|version|postversion|pretest|test|posttest|prestop|stop|poststop|prestart|start|poststart|prerestart|restart|postrestart|serve)$"]: string}
		}

		// A 'config' hash can be used to set configuration parameters used in package
		// scripts that persist across upgrades.
		"config"?:               {...}
		"dependencies"?:         #dependency
		"devDependencies"?:      #devDependency
		"optionalDependencies"?: #optionalDependency
		"peerDependencies"?:     #peerDependency
		"peerDependenciesMeta"?: #peerDependencyMeta

		// Array of package names that will be bundled when publishing the package.
		"bundleDependencies"?: matchN(1, [[...string], bool])

		// DEPRECATED: This field is honored, but "bundleDependencies" is the correct
		// field name. Ignored if "bundleDependencies" is also present.
		"bundledDependencies"?: matchN(1, [[...string], bool])

		// Resolutions is used to support selective version resolutions using yarn,
		// which lets you define custom package versions or ranges inside your
		// dependencies. For npm, use overrides instead. See:
		// https://yarnpkg.com/configuration/manifest#resolutions
		"resolutions"?: {...}

		// Overrides is used to support selective version overrides using npm, which
		// lets you define custom package versions or ranges inside your dependencies.
		// For yarn, use resolutions instead. See:
		// https://docs.npmjs.com/cli/v9/configuring-npm/package-json#overrides
		"overrides"?: {...}

		// Defines which package manager is expected to be used when working on the
		// current project. This field is currently experimental and needs to be
		// opted-in; see https://nodejs.org/api/corepack.html
		"packageManager"?: matchN(1, [=~"(npm|pnpm|yarn|bun|aube|nub)@\\d+\\.\\d+\\.\\d+(-.+)?", "bun"])
		"engines"?: {
			"node"?: string

			// Specifies which JavaScript runtimes (like Node.js, Deno, Bun) are supported.
			// Values should use WinterCG Runtime Keys (see
			// https://runtime-keys.proposal.wintercg.org/).
			"runtime"?: matchN(1, [#runtimeEngineDependency, [...#runtimeEngineDependency]])
			{[!~"^(node|runtime)$"]: string}
		}

		// Defines which tools and versions are expected to be used when Volta is installed.
		"volta"?: {
			// The value of that entry should be a path to another JSON file which also has a "volta" section
			"extends"?: string

			{[=~"(node|npm|pnpm|yarn)"]: string}
			...
		}
		"engineStrict"?: bool

		// Specify which operating systems your module will run on.
		"os"?: [...string]

		// Specify that your code only runs on certain cpu architectures.
		"cpu"?: [...string]

		// Define the runtime and package manager for developing the current project.
		"devEngines"?: {
			// Specifies which operating systems are supported for development
			"os"?: matchN(1, [#devEngineDependency, [...#devEngineDependency]])

			// Specifies which CPU architectures are supported for development
			"cpu"?: matchN(1, [#devEngineDependency, [...#devEngineDependency]])

			// Specifies which C standard libraries are supported for development
			"libc"?: matchN(1, [#devEngineDependency, [...#devEngineDependency]])

			// Specifies which JavaScript runtimes (like Node.js, Deno, Bun) are supported
			// for development. Values should use WinterCG Runtime Keys (see
			// https://runtime-keys.proposal.wintercg.org/)
			"runtime"?: matchN(1, [#devEngineDependency, [...#devEngineDependency]])

			// Specifies which package managers are supported for development
			"packageManager"?: matchN(1, [#devEngineDependency, [...#devEngineDependency]])
			...
		}

		// DEPRECATED: This option used to trigger an npm warning, but it will no longer
		// warn. It is purely there for informational purposes. It is now recommended
		// that you install any binaries as local devDependencies wherever possible.
		"preferGlobal"?: bool

		// If set to true, then npm will refuse to publish it.
		"private"?: matchN(1, [bool, "false" | "true"])
		"publishConfig"?: {
			"access"?:     "public" | "restricted"
			"tag"?:        string
			"registry"?:   net.AbsURL
			"provenance"?: bool
			...
		}
		"dist"?: {
			"shasum"?:  string
			"tarball"?: string
			...
		}
		"readme"?: string

		// An ECMAScript module ID that is the primary entry point to your program.
		"module"?: string

		// A module ID with untranspiled code that is the primary entry point to your program.
		"esnext"?: string | {
			"main"?:    string
			"browser"?: string
			{[!~"^(main|browser)$"]: string}
		}

		// Allows packages within a directory to depend on one another using direct
		// linking of local files. Additionally, dependencies within a workspace are
		// hoisted to the workspace root when possible to reduce duplication. Note:
		// It's also a good idea to set "private" to true when using this feature.
		"workspaces"?: matchN(>=1, [
			[...string],
			{
				// Workspace package paths. Glob patterns are supported.
				"packages"?: [...string]

				// Packages to block from hoisting to the workspace root. Currently only supported in Yarn only.
				"nohoist"?: [...string]
				...
			}
		])
		"jspm"?:          _schema
		"eslintConfig"?:  eslint.#Schema
		"prettier"?:      prettier.#Schema
		"stylelint"?:     stylelint.#Schema
		"ava"?:           ava.#Schema
		"release"?:       semanticrelease.#Schema
		"jscpd"?:         jscpd.#Schema
		"madge"?:         madge.#Schema
		"nodemonConfig"?: nodemon.#Schema
		"quikrun"?:       quikrun.#Schema

		// Defines pnpm specific configuration.
		"pnpm"?: close({
			// Used to override any dependency in the dependency graph.
			"overrides"?: {...}

			// Used to extend the existing package definitions with additional information.
			"packageExtensions"?: close({

				{
					[=~"^.+$"]: close({
						"dependencies"?:         #dependency
						"optionalDependencies"?: #optionalDependency
						"peerDependencies"?:     #peerDependency
						"peerDependenciesMeta"?: #peerDependencyMeta
					})
				}})
			"peerDependencyRules"?: close({
				// pnpm will not print warnings about missing peer dependencies from this list.
				"ignoreMissing"?: [...string]

				// Unmet peer dependency warnings will not be printed for peer dependencies of the specified range.
				"allowedVersions"?: {...}

				// Any peer dependency matching the pattern will be resolved from any version,
				// regardless of the range specified in "peerDependencies".
				"allowAny"?: [...string]
			})

			// A list of dependencies to run builds for.
			"neverBuiltDependencies"?: [...string]

			// A list of package names that are allowed to be executed during installation.
			"onlyBuiltDependencies"?: [...string]

			// Specifies a JSON file that lists the only packages permitted to run
			// installation scripts during the pnpm install process.
			"onlyBuiltDependenciesFile"?: string

			// A list of package names that should not be built during installation.
			"ignoredBuiltDependencies"?: [...string]

			// A list of deprecated versions that the warnings are suppressed.
			"allowedDeprecatedVersions"?: {...}

			// A list of dependencies that are patched.
			"patchedDependencies"?: {...}

			// When true, installation won't fail if some of the patches from the
			// "patchedDependencies" field were not applied.
			"allowNonAppliedPatches"?: bool

			// When true, installation won't fail if some of the patches from the
			// "patchedDependencies" field were not applied.
			"allowUnusedPatches"?: bool
			"updateConfig"?: close({
				// A list of packages that should be ignored when running "pnpm outdated" or "pnpm update --latest".
				"ignoreDependencies"?: [...string]
			})

			// Configurational dependencies are installed before all the other types of
			// dependencies (before 'dependencies', 'devDependencies',
			// 'optionalDependencies').
			"configDependencies"?: {...}
			"auditConfig"?: close({
				// A list of CVE IDs that will be ignored by "pnpm audit".
				"ignoreCves"?: [...=~"^CVE-\\d{4}-\\d{4,7}$"]

				// A list of GHSA Codes that will be ignored by "pnpm audit".
				"ignoreGhsas"?: [...=~"^GHSA(-[23456789cfghjmpqrvwx]{4}){3}$"]
			})

			// A list of scripts that must exist in each project.
			"requiredScripts"?: [...string]

			// Specifies architectures for which you'd like to install optional
			// dependencies, even if they don't match the architecture of the system
			// running the install.
			"supportedArchitectures"?: close({
				"os"?:   [...string]
				"cpu"?:  [...string]
				"libc"?: [...string]
			})

			// A list of optional dependencies that the install should be skipped.
			"ignoredOptionalDependencies"?: [...string]
			"executionEnv"?: close({
				// Specifies which exact Node.js version should be used for the project's runtime.
				"nodeVersion"?: string
			})
		})

		// Defines the StackBlitz configuration for the project.
		"stackblitz"?: close({
			// StackBlitz automatically installs npm dependencies when opening a project.
			"installDependencies"?: bool

			// A terminal command to be executed when opening the project, after installing npm dependencies.
			"startCommand"?: bool | string

			// The compileTrigger option controls how file changes in the editor are written
			// to the WebContainers in-memory filesystem.
			"compileTrigger"?: "auto" | "keystroke" | "save"

			// A map of default environment variables that will be set in each top-level shell process.
			"env"?: {...}
		})

		// Records which dependencies are permitted to run install scripts (preinstall,
		// install, postinstall, and prepare for non-registry sources). Maintained via
		// the "npm approve-scripts" command, which enforces a default-deny policy:
		// install scripts for any dependency without a matching entry are silently
		// skipped. Keys are package identifiers — either name-only (e.g. "pkg") or
		// pinned with a version (e.g. "pkg@1.2.3"); by default entries are pinned so
		// approval is version-specific. A value of true allows the dependency's
		// install scripts to run, while false explicitly denies them (existing false
		// entries are never silently overridden).
		"allowScripts"?: [string]: bool

		// Provides hints to the Webpack compiler, denoting which files in your project
		// are "pure" and therefore safe to prune if unused.
		"sideEffects"?: matchN(1, [bool, list.UniqueItems() & [...string]])
		...

		// Dependencies are specified with a simple hash of package name to version
		// range. The version range is a string which has one or more space-separated
		// descriptors. Dependencies can also be identified with a tarball or git URL.
		#dependency: [string]: string

		// Specifies dependencies that are required for the development and testing of
		// the project. These dependencies are not needed in the production
		// environment.
		#devDependency: [string]: string

		// Specifies requirements for development environment components such as
		// operating systems, runtimes, or package managers. Used to ensure consistent
		// development environments across the team.
		#devEngineDependency: {
			// The name of the dependency, with allowed values depending on the parent field
			"name"!: string

			// The version range for the dependency
			"version"?: string

			// What action to take if validation fails
			"onFail"?: "ignore" | "warn" | "error" | "download"
			...
		}

		// URL to a website with details about how to fund the package.
		#fundingUrl: net.AbsURL

		// Used to inform about ways to help fund development of the package.
		#fundingWay: close({
			"url"!: #fundingUrl

			// The type of funding or the platform through which funding can be provided,
			// e.g. patreon, opencollective, tidelift or github.
			"type"?: string
		})

		#license: matchN(>=1, [
			string,
			"AGPL-3.0-only" |
				"Apache-2.0" |
				"BSD-2-Clause" |
				"BSD-3-Clause" |
				"BSL-1.0" |
				"CC0-1.0" |
				"CDDL-1.0" |
				"CDDL-1.1" |
				"EPL-1.0" |
				"EPL-2.0" |
				"GPL-2.0-only" |
				"GPL-3.0-only" |
				"ISC" |
				"LGPL-2.0-only" |
				"LGPL-2.1-only" |
				"LGPL-2.1-or-later" |
				"LGPL-3.0-only" |
				"LGPL-3.0-or-later" |
				"MIT" |
				"MPL-2.0" |
				"MS-PL" |
				"UNLICENSED",
		])

		// Specifies dependencies that are optional for your project. These dependencies
		// are attempted to be installed during the npm install process, but if they
		// fail to install, the installation process will not fail.
		#optionalDependency: [string]: string

		#packageExportsEntry: matchN(1, [#packageExportsEntryPath, #packageExportsEntryObject])

		// Used to specify conditional exports, note that Conditional exports are
		// unsupported in older environments, so it's recommended to use the fallback
		// array option if support for those environments is a concern.
		#packageExportsEntryObject: close({
			"require"?:     #packageExportsEntryOrFallback
			"import"?:      #packageExportsEntryOrFallback
			"module-sync"?: #packageExportsEntryOrFallback
			"node"?:        #packageExportsEntryOrFallback
			"default"?:     #packageExportsEntryOrFallback
			"types"?:       #packageExportsEntryOrFallback

			{[=~"^[^.0-9]+$"]: #packageExportsEntryOrFallback}

			{[=~"^types@.+$"]: #packageExportsEntryOrFallback}
		})

		#packageExportsEntryOrFallback: matchN(1, [#packageExportsEntry, #packageExportsFallback])

		// The module path that is resolved when this specifier is imported. Set to
		// `null` to disallow importing this module.
		#packageExportsEntryPath: null | =~"^\\./"

		// Used to allow fallbacks in case this environment doesn't support the preceding entries.
		#packageExportsFallback: [...#packageExportsEntry]

		#packageImportsEntry: matchN(1, [#packageImportsEntryPath, #packageImportsEntryObject])

		// Used to specify conditional exports, note that Conditional exports are
		// unsupported in older environments, so it's recommended to use the fallback
		// array option if support for those environments is a concern.
		#packageImportsEntryObject: close({
			"require"?: #packageImportsEntryOrFallback
			"import"?:  #packageImportsEntryOrFallback
			"node"?:    #packageImportsEntryOrFallback
			"default"?: #packageImportsEntryOrFallback
			"types"?:   #packageImportsEntryOrFallback

			{[=~"^[^.0-9]+$"]: #packageImportsEntryOrFallback}

			{[=~"^types@.+$"]: #packageImportsEntryOrFallback}
		})

		#packageImportsEntryOrFallback: matchN(1, [#packageImportsEntry, #packageImportsFallback])

		// The module path that is resolved when this specifier is imported. Set to
		// `null` to disallow importing this module.
		#packageImportsEntryPath: null | string

		// Used to allow fallbacks in case this environment doesn't support the preceding entries.
		#packageImportsFallback: [...#packageImportsEntry]

		// Specifies dependencies that are required by the package but are expected to
		// be provided by the consumer of the package.
		#peerDependency: [string]: string

		// When a user installs your package, warnings are emitted if packages specified
		// in "peerDependencies" are not already installed. The "peerDependenciesMeta"
		// field serves to provide more information on how your peer dependencies are
		// utilized. Most commonly, it allows peer dependencies to be marked as
		// optional. Metadata for this field is specified with a simple hash of the
		// package name to a metadata object.
		#peerDependencyMeta: [string]: {
			// Specifies that this peer dependency is optional and should not be installed automatically.
			"optional"?: bool
			...
		}

		// A person who has been involved in creating or maintaining this package.
		#person: string | {
			"name"!:  string
			"url"?:   net.AbsURL
			"email"?: string
			...
		}

		// Specifies a supported JavaScript runtime.
		#runtimeEngineDependency: {
			// The runtime name
			"name"!: string

			// The version range for the runtime
			"version"?: string

			// What action to take if runtime validation fails
			"onFail"?: "ignore" | "warn" | "error" | "download"
			...
		}

		// Run AFTER the package is installed.
		#scriptsInstallAfter: string

		// Run AFTER the package is published.
		#scriptsPublishAfter: string

		// Run by the 'npm restart' command. Note: 'npm restart' will run the stop and
		// start scripts if no restart script is provided.
		#scriptsRestart: string

		// Run by the 'npm start' command.
		#scriptsStart: string

		// Run by the 'npm stop' command.
		#scriptsStop: string

		// Run by the 'npm test' command.
		#scriptsTest: string

		// Run BEFORE the package is uninstalled.
		#scriptsUninstallBefore: string

		// Run BEFORE bump the package version.
		#scriptsVersionBefore: string
	}
}