npmeta 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roman A
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,60 @@
+type ModuleFormat = "esm" | "cjs" | "dual" | "wasm" | "binary" | "empty" | "unknown";
+/**
+ * Extended package.json fields
+ */
+interface ExtendedPackageJson {
+  name?: string;
+  version?: string;
+  type?: "module" | "commonjs";
+  main?: string;
+  module?: string;
+  types?: string;
+  typings?: string;
+  exports?: PackageExports;
+  bin?: string | Record<string, string>;
+  engines?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+}
+type PackageExports = string | null | {
+  [key: string]: PackageExports;
+} | PackageExports[];
+/**
+ * Detect the module format of a package based on package.json fields
+ */
+declare function detectModuleFormat(pkg: ExtendedPackageJson): ModuleFormat;
+declare function hasBuiltInTypes(pkg: ExtendedPackageJson): boolean;
+interface PackageMetadata {
+  name: string;
+  bin?: string | Record<string, string>;
+  main?: string;
+  module?: unknown;
+  exports?: unknown;
+}
+declare function isBinaryOnlyPackage(pkg: PackageMetadata): boolean;
+declare function isCreatePackage(packageName: string): boolean;
+declare function getCreatePackageName(packageName: string): string;
+declare function getCreateShortName(createPackageName: string): string;
+/** Parsed result of an npm dependency version value */
+interface ParsedDependencyVersion {
+  /** The real package name (different from the dependency key only for aliases) */
+  name: string | null;
+  /** The semver range or version, null for non-resolvable values (file:, git, etc.) */
+  range: string | null;
+}
+declare function parseDependencyVersion(value: string): ParsedDependencyVersion;
+declare function normalizeLicense(license?: string | {
+  type: string;
+}): string | undefined;
+declare function splitPackageName(packageName: string): {
+  org: string;
+  name: string;
+};
+declare function getTypesPackageName(packageName: string): string;
+declare function encodePackageName(name: string): string;
+declare function parsePackageSpec(input: string): {
+  name: string;
+  version?: string;
+};
+export { detectModuleFormat, encodePackageName, getCreatePackageName, getCreateShortName, getTypesPackageName, hasBuiltInTypes, isBinaryOnlyPackage, isCreatePackage, normalizeLicense, parseDependencyVersion, parsePackageSpec, splitPackageName };

package/dist/index.mjs

@@ -0,0 +1,174 @@
+// src/create-package.ts
+function isCreatePackage(packageName) {
+	return (packageName.startsWith("@") ? packageName.split("/")[1] : packageName)?.startsWith("create-") || packageName.includes("/create-") || false;
+}
+function getCreatePackageName(packageName) {
+	if (!packageName.startsWith("@")) return `create-${packageName}`;
+	const slashIndex = packageName.indexOf("/");
+	return `${packageName.slice(0, slashIndex)}/create-${packageName.slice(slashIndex + 1)}`;
+}
+function getCreateShortName(createPackageName) {
+	if (createPackageName.startsWith("create-")) return createPackageName.slice(7);
+	if (!createPackageName.startsWith("@")) return createPackageName;
+	const slashIndex = createPackageName.indexOf("/");
+	const scope = createPackageName.slice(0, slashIndex);
+	const name = createPackageName.slice(slashIndex + 1);
+	if (name === "create") return scope;
+	if (name.startsWith("create-")) return `${scope}/${name.slice(7)}`;
+	return createPackageName;
+}
+// src/binary-detection.ts
+function hasBin(pkg) {
+	return pkg.bin != null && (typeof pkg.bin === "string" || Object.keys(pkg.bin).length > 0);
+}
+function isBinaryOnlyPackage(pkg) {
+	if (isCreatePackage(pkg.name)) return true;
+	const hasEntryPoint = !!pkg.main || !!pkg.module || pkg.exports != null;
+	return hasBin(pkg) && !hasEntryPoint;
+}
+// src/analysis.ts
+function analyzeExports(exports, isTypeModule, depth = 0) {
+	const result = {
+		hasImport: false,
+		hasRequire: false,
+		hasModule: false,
+		hasTypes: false
+	};
+	if (depth > 10) return result;
+	if (exports == null) return result;
+	if (typeof exports === "string") {
+		if (exports === "./package.json") return result;
+		if (exports.endsWith(".mjs") || exports.endsWith(".mts") || exports.endsWith(".json")) result.hasImport = true;
+		else if (exports.endsWith(".cjs") || exports.endsWith(".cts")) result.hasRequire = true;
+		else if (exports.endsWith(".js")) {
+			if (isTypeModule) result.hasImport = true;
+			else result.hasRequire = true;
+		}
+		if (exports.endsWith(".d.ts") || exports.endsWith(".d.mts") || exports.endsWith(".d.cts")) result.hasTypes = true;
+		return result;
+	}
+	if (Array.isArray(exports)) {
+		for (const item of exports) mergeExportsAnalysis(result, analyzeExports(item, isTypeModule, depth + 1));
+		return result;
+	}
+	if (typeof exports === "object") for (const [key, value] of Object.entries(exports)) {
+		if (key === "import") result.hasImport = true;
+		else if (key === "require") result.hasRequire = true;
+		else if (key === "module") result.hasModule = true;
+		else if (key === "types") result.hasTypes = true;
+		mergeExportsAnalysis(result, analyzeExports(value, isTypeModule, depth + 1));
+	}
+	return result;
+}
+function mergeExportsAnalysis(target, source) {
+	target.hasImport ||= source.hasImport;
+	target.hasRequire ||= source.hasRequire;
+	target.hasModule ||= source.hasModule;
+	target.hasTypes ||= source.hasTypes;
+}
+function detectModuleFormat(pkg) {
+	const hasExports = pkg.exports != null;
+	const hasModule = !!pkg.module;
+	const hasMain = !!pkg.main;
+	if (!hasExports && !hasModule && !hasMain) {
+		if (hasBin(pkg)) return "binary";
+		return "empty";
+	}
+	const isTypeModule = pkg.type === "module";
+	const isTypeCommonjs = pkg.type === "commonjs" || !pkg.type;
+	if (hasExports && pkg.exports) {
+		const exportInfo = analyzeExports(pkg.exports, isTypeModule);
+		if (exportInfo.hasImport && exportInfo.hasRequire) return "dual";
+		if (exportInfo.hasImport || exportInfo.hasModule) {
+			if (hasMain && !isTypeModule) return "dual";
+			return "esm";
+		}
+		if (exportInfo.hasRequire) {
+			if (hasModule) return "dual";
+			return "cjs";
+		}
+	}
+	if (hasModule && hasMain) return pkg.main?.endsWith(".cjs") || pkg.main?.endsWith(".js") && !isTypeModule ? "dual" : "esm";
+	if (pkg.main?.endsWith(".wasm")) return "wasm";
+	if (hasModule || isTypeModule) return "esm";
+	if (hasMain || isTypeCommonjs) return "cjs";
+	return "unknown";
+}
+function hasBuiltInTypes(pkg) {
+	if (pkg.types || pkg.typings) return true;
+	if (pkg.exports) {
+		if (analyzeExports(pkg.exports, pkg.type === "module").hasTypes) return true;
+	}
+	return false;
+}
+// src/dependency-version.ts
+const GIT_REFERENCE_RE = /^(?:git(?:\+(?:ssh|https?|file))?:|github:)/;
+const HTTP_REFERENCE_RE = /^https?:\/\//;
+function isNonSemverConstraint(constraint) {
+	return GIT_REFERENCE_RE.test(constraint) || HTTP_REFERENCE_RE.test(constraint) || constraint.startsWith("file:") || constraint.startsWith("link:") || constraint.startsWith("workspace:") || constraint.includes("/");
+}
+function parseDependencyVersion(value) {
+	if (value.startsWith("npm:")) {
+		const aliasBody = value.slice(4);
+		if (aliasBody.startsWith("@")) {
+			const secondAt = aliasBody.indexOf("@", 1);
+			if (secondAt !== -1) return {
+				name: aliasBody.slice(0, secondAt),
+				range: aliasBody.slice(secondAt + 1)
+			};
+			return {
+				name: aliasBody,
+				range: null
+			};
+		}
+		const atIndex = aliasBody.indexOf("@");
+		if (atIndex !== -1) return {
+			name: aliasBody.slice(0, atIndex),
+			range: aliasBody.slice(atIndex + 1)
+		};
+		return {
+			name: aliasBody,
+			range: null
+		};
+	}
+	if (isNonSemverConstraint(value)) return {
+		name: null,
+		range: null
+	};
+	return {
+		name: null,
+		range: value
+	};
+}
+// src/normalize.ts
+function normalizeLicense(license) {
+	if (!license) return void 0;
+	if (typeof license === "string") return license;
+	if (typeof license.type === "string") return license.type;
+}
+// src/package-name.ts
+function splitPackageName(packageName) {
+	const [org = "", name = ""] = packageName.startsWith("@") ? packageName.split("/") : ["", packageName];
+	return {
+		org,
+		name
+	};
+}
+function getTypesPackageName(packageName) {
+	if (packageName.startsWith("@")) return `@types/${packageName.slice(1).replace("/", "__")}`;
+	return `@types/${packageName}`;
+}
+function encodePackageName(name) {
+	return name.replace("/", "%2F");
+}
+// src/package-spec.ts
+function parsePackageSpec(input) {
+	const trimmedInput = input.trim();
+	const atPos = trimmedInput.lastIndexOf("@");
+	if (atPos <= 0) return { name: trimmedInput };
+	return {
+		name: trimmedInput.slice(0, atPos).trim(),
+		version: trimmedInput.slice(atPos + 1).trim()
+	};
+}
+export { detectModuleFormat, encodePackageName, getCreatePackageName, getCreateShortName, getTypesPackageName, hasBuiltInTypes, isBinaryOnlyPackage, isCreatePackage, normalizeLicense, parseDependencyVersion, parsePackageSpec, splitPackageName };

package/package.json

@@ -1,4 +1,39 @@
 {
   "name": "npmeta",
-  "version": "0.0.0"
+  "version": "0.1.0",
+  "license": "MIT",
+  "author": "gameroman",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gameroman-npm/npmeta.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "u": "bun --sequential format build test:bun test",
+    "test": "node --test",
+    "test:bun": "bun test --dots",
+    "lint": "oxlint",
+    "format": "oxfmt",
+    "build": "tsdown",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@gameroman/config": "0.3.0",
+    "@types/node": "26.6.6",
+    "oxfmt": "0.75.0",
+    "oxlint": "1.90.0",
+    "oxlint-tsgolint": "7.0.2005",
+    "tsdown": "0.23.3",
+    "typescript": "7.0.2"
+  },
+  "engines": {
+    "node": ">=22"
+  }
 }