@verdaccio/store 9.0.0-next-9.2 → 9.0.0-next-9.4

package/build/lib/storage-utils.js

@@ -1,357 +1,281 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WHITELIST = exports.STORAGE = void 0;
-exports.checkPackageRemote = checkPackageRemote;
-exports.cleanUpLinksRef = cleanUpLinksRef;
-exports.cleanUpReadme = cleanUpReadme;
-exports.generatePackageTemplate = generatePackageTemplate;
-exports.generateRevision = generateRevision;
-exports.getLatestReadme = getLatestReadme;
-exports.hasDeprecatedVersions = hasDeprecatedVersions;
-exports.isDeprecatedManifest = isDeprecatedManifest;
-exports.mapManifestToSearchPackageBody = mapManifestToSearchPackageBody;
-exports.mergeUplinkTimeIntoLocal = mergeUplinkTimeIntoLocal;
-exports.mergeUplinkTimeIntoLocalNext = mergeUplinkTimeIntoLocalNext;
-exports.mergeVersions = mergeVersions;
-exports.normalizeContributors = normalizeContributors;
-exports.normalizeDistTags = normalizeDistTags;
-exports.normalizePackage = normalizePackage;
-exports.prepareSearchPackage = prepareSearchPackage;
-exports.updateUpLinkMetadata = updateUpLinkMetadata;
-var _lodash = _interopRequireDefault(require("lodash"));
-var _semver = _interopRequireDefault(require("semver"));
-var _core = require("@verdaccio/core");
-var _versionsUtils = require("./versions-utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var STORAGE = exports.STORAGE = {
-  PACKAGE_FILE_NAME: 'package.json',
-  FILE_EXIST_ERROR: 'EEXISTS',
-  NO_SUCH_FILE_ERROR: 'ENOENT',
-  DEFAULT_REVISION: '0-0000000000000000'
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_versions_utils = require("./versions-utils.js");
+let lodash = require("lodash");
+lodash = require_runtime.__toESM(lodash);
+let _verdaccio_core = require("@verdaccio/core");
+let semver = require("semver");
+semver = require_runtime.__toESM(semver);
+//#region src/lib/storage-utils.ts
+var STORAGE = {
+	PACKAGE_FILE_NAME: "package.json",
+	FILE_EXIST_ERROR: "EEXISTS",
+	NO_SUCH_FILE_ERROR: "ENOENT",
+	DEFAULT_REVISION: "0-0000000000000000"
 };
-
 /**
- * Create a new package in the storage, return a boilerplate package
- * @param name package name
- * @returns {Manifest}
- */
+* Create a new package in the storage, return a boilerplate package
+* @param name package name
+* @returns {Manifest}
+*/
 function generatePackageTemplate(name) {
-  return _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
-    // standard things
-    name: name,
-    versions: {},
-    time: {}
-  }, _core.USERS, {}), _core.DIST_TAGS, {}), _core.MAINTAINERS, []), "_uplinks", {}), "_distfiles", {}), "_attachments", {}), "_rev", '');
+	return {
+		name,
+		versions: {},
+		time: {},
+		[_verdaccio_core.USERS]: {},
+		[_verdaccio_core.DIST_TAGS]: {},
+		[_verdaccio_core.MAINTAINERS]: [],
+		_uplinks: {},
+		_distfiles: {},
+		_attachments: {},
+		_rev: ""
+	};
 }
-
 /**
- * Normalize package properties, tags, revision id.
- * @param {Object} pkg package reference.
- */
+* Normalize package properties, tags, revision id.
+* @param {Object} pkg package reference.
+*/
 function normalizePackage(pkg) {
-  var pkgProperties = ['versions', 'dist-tags', '_distfiles', '_attachments', '_uplinks', 'time'];
-  pkgProperties.forEach(function (key) {
-    var pkgProp = pkg[key];
-    if (_lodash["default"].isNil(pkgProp) || _core.validationUtils.isObject(pkgProp) === false) {
-      pkg[key] = {};
-    }
-  });
-  if (typeof (pkg === null || pkg === void 0 ? void 0 : pkg._rev) !== 'string') {
-    pkg._rev = STORAGE.DEFAULT_REVISION;
-  }
-  if (typeof (pkg === null || pkg === void 0 ? void 0 : pkg._id) !== 'string') {
-    pkg._id = pkg.name;
-  }
-
-  // normalize dist-tags
-  return normalizeDistTags(pkg);
+	[
+		"versions",
+		"dist-tags",
+		"_distfiles",
+		"_attachments",
+		"_uplinks",
+		"time"
+	].forEach((key) => {
+		const pkgProp = pkg[key];
+		if (lodash.default.isNil(pkgProp) || _verdaccio_core.validationUtils.isObject(pkgProp) === false) pkg[key] = {};
+	});
+	if (typeof pkg?._rev !== "string") pkg._rev = STORAGE.DEFAULT_REVISION;
+	if (typeof pkg?._id !== "string") pkg._id = pkg.name;
+	return normalizeDistTags(pkg);
 }
 function generateRevision(rev) {
-  var _rev = rev.split('-');
-  return (+_rev[0] || 0) + 1 + '-' + _core.cryptoUtils.generateRandomHexString();
+	return (+rev.split("-")[0] || 0) + 1 + "-" + _verdaccio_core.cryptoUtils.generateRandomHexString();
 }
 function getLatestReadme(pkg) {
-  var versions = pkg['versions'] || {};
-  var distTags = pkg[_core.DIST_TAGS] || {};
-  // FIXME: here is a bit tricky add the types
-  var latestVersion = distTags['latest'] ? versions[distTags['latest']] || {} : {};
-  var readme = _lodash["default"].trim(pkg.readme || latestVersion.readme || '');
-  if (readme) {
-    return readme;
-  }
-
-  // In case of empty readme - trying to get ANY readme in the following order:
-  // 'next','beta','alpha','test','dev','canary'
-  var readmeDistTagsPriority = ['next', 'beta', 'alpha', 'test', 'dev', 'canary'];
-  readmeDistTagsPriority.forEach(function (tag) {
-    if (readme) {
-      return readme;
-    }
-    var version = distTags[tag] ? versions[distTags[tag]] || {} : {};
-    readme = _lodash["default"].trim(version.readme || readme);
-  });
-  return readme;
+	const versions = pkg["versions"] || {};
+	const distTags = pkg[_verdaccio_core.DIST_TAGS] || {};
+	const latestVersion = distTags["latest"] ? versions[distTags["latest"]] || {} : {};
+	let readme = lodash.default.trim(pkg.readme || latestVersion.readme || "");
+	if (readme) return readme;
+	[
+		"next",
+		"beta",
+		"alpha",
+		"test",
+		"dev",
+		"canary"
+	].forEach(function(tag) {
+		if (readme) return readme;
+		const version = distTags[tag] ? versions[distTags[tag]] || {} : {};
+		readme = lodash.default.trim(version.readme || readme);
+	});
+	return readme;
 }
-
 /**
- * Cleanup readme from package version
- *
- * By default, we don't keep readmes for package versions, only one readme per package.
- * Using publish.keep_readmes you can override this behavior and keep all readmes
- * or only readmes for tagged versions.
- */
+* Cleanup readme from package version
+*
+* By default, we don't keep readmes for package versions, only one readme per package.
+* Using publish.keep_readmes you can override this behavior and keep all readmes
+* or only readmes for tagged versions.
+*/
 function cleanUpReadme(version, distTags, keepReadmes) {
-  if (keepReadmes === 'all') {
-    return version;
-  } else if (keepReadmes === 'tagged') {
-    if (distTags && Object.values(distTags).includes(version.version)) {
-      return version;
-    }
-  }
-  if (_lodash["default"].isNil(version) === false) {
-    version.readme = '';
-  }
-  return version;
+	if (keepReadmes === "all") return version;
+	else if (keepReadmes === "tagged") {
+		if (distTags && Object.values(distTags).includes(version.version)) return version;
+	}
+	if (lodash.default.isNil(version) === false) version.readme = "";
+	return version;
 }
-var WHITELIST = exports.WHITELIST = ['_rev', 'name', 'versions', 'dist-tags', 'readme', 'time', '_id', 'users', 'maintainers'];
+var WHITELIST = [
+	"_rev",
+	"name",
+	"versions",
+	"dist-tags",
+	"readme",
+	"time",
+	"_id",
+	"users",
+	"maintainers"
+];
 function cleanUpLinksRef(result, keepUpLinkData) {
-  var propertyToKeep = [].concat(WHITELIST);
-  if (keepUpLinkData === true) {
-    propertyToKeep.push('_uplinks');
-  }
-  for (var i in result) {
-    if (propertyToKeep.indexOf(i) === -1) {
-      // Remove sections like '_uplinks' from response
-      delete result[i];
-    }
-  }
-  return result;
+	const propertyToKeep = [...WHITELIST];
+	if (keepUpLinkData === true) propertyToKeep.push("_uplinks");
+	for (const i in result) if (propertyToKeep.indexOf(i) === -1) delete result[i];
+	return result;
 }
-
-// TODO: move to abstract storage
-// @deprecated use abstract.storage.ts:checkPackageRemote
 function checkPackageRemote(name, isAllowPublishOffline, syncMetadata) {
-  return new Promise(function (resolve, reject) {
-    syncMetadata(name, null, {}, function (err, packageJsonLocal, upLinksErrors) {
-      // something weird
-      if (err && err.status !== _core.HTTP_STATUS.NOT_FOUND) {
-        return reject(err);
-      }
-
-      // checking package exist already
-      if (_lodash["default"].isNil(packageJsonLocal) === false) {
-        return reject(_core.errorUtils.getConflict(_core.API_ERROR.PACKAGE_EXIST));
-      }
-      for (var errorItem = 0; errorItem < upLinksErrors.length; errorItem++) {
-        // checking error
-        // if uplink fails with a status other than 404, we report failure
-        if (_lodash["default"].isNil(upLinksErrors[errorItem][0]) === false) {
-          if (upLinksErrors[errorItem][0].status !== _core.HTTP_STATUS.NOT_FOUND) {
-            if (isAllowPublishOffline) {
-              return resolve();
-            }
-            return reject(_core.errorUtils.getServiceUnavailable(_core.API_ERROR.UPLINK_OFFLINE_PUBLISH));
-          }
-        }
-      }
-      return resolve();
-    });
-  });
+	return new Promise((resolve, reject) => {
+		syncMetadata(name, null, {}, (err, packageJsonLocal, upLinksErrors) => {
+			if (err && err.status !== _verdaccio_core.HTTP_STATUS.NOT_FOUND) return reject(err);
+			if (lodash.default.isNil(packageJsonLocal) === false) return reject(_verdaccio_core.errorUtils.getConflict(_verdaccio_core.API_ERROR.PACKAGE_EXIST));
+			for (let errorItem = 0; errorItem < upLinksErrors.length; errorItem++) if (lodash.default.isNil(upLinksErrors[errorItem][0]) === false) {
+				if (upLinksErrors[errorItem][0].status !== _verdaccio_core.HTTP_STATUS.NOT_FOUND) {
+					if (isAllowPublishOffline) return resolve();
+					return reject(_verdaccio_core.errorUtils.getServiceUnavailable(_verdaccio_core.API_ERROR.UPLINK_OFFLINE_PUBLISH));
+				}
+			}
+			return resolve();
+		});
+	});
 }
-
-// @deprecated use export function mergeUplinkTimeIntoLocalNext
 function mergeUplinkTimeIntoLocal(localMetadata, remoteMetadata) {
-  if ('time' in remoteMetadata) {
-    return Object.assign({}, localMetadata.time, remoteMetadata.time);
-  }
-  return localMetadata.time;
+	if ("time" in remoteMetadata) return Object.assign({}, localMetadata.time, remoteMetadata.time);
+	return localMetadata.time;
 }
 function mergeUplinkTimeIntoLocalNext(cacheManifest, remoteManifest) {
-  if ('time' in remoteManifest) {
-    // remote override cache time conflicts
-    return _objectSpread(_objectSpread({}, cacheManifest), {}, {
-      time: _objectSpread(_objectSpread({}, cacheManifest.time), remoteManifest.time)
-    });
-  }
-  return cacheManifest;
+	if ("time" in remoteManifest) return {
+		...cacheManifest,
+		time: {
+			...cacheManifest.time,
+			...remoteManifest.time
+		}
+	};
+	return cacheManifest;
 }
 function updateUpLinkMetadata(uplinkName, manifest, etag) {
-  var _uplinks = _objectSpread(_objectSpread({}, manifest._uplinks), {}, _defineProperty({}, uplinkName, {
-    etag: etag,
-    fetched: Date.now()
-  }));
-  return _objectSpread(_objectSpread({}, manifest), {}, {
-    _uplinks: _uplinks
-  });
+	const _uplinks = {
+		...manifest._uplinks,
+		[uplinkName]: {
+			etag,
+			fetched: Date.now()
+		}
+	};
+	return {
+		...manifest,
+		_uplinks
+	};
 }
 function prepareSearchPackage(data) {
-  var latest = _core.pkgUtils.getLatest(data);
-  if (latest && data.versions[latest]) {
-    var version = data.versions[latest];
-    var versions = _defineProperty({}, latest, 'latest');
-    var pkg = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
-      name: version.name,
-      description: version.description
-    }, _core.DIST_TAGS, {
-      latest: latest
-    }), "maintainers", version.maintainers || [version.author].filter(Boolean)), "author", version.author), "repository", version.repository), "readmeFilename", version.readmeFilename || ''), "homepage", version.homepage), "keywords", version.keywords), "bugs", version.bugs), "license", version.license), "versions", versions);
-    return pkg;
-  }
+	const latest = _verdaccio_core.pkgUtils.getLatest(data);
+	if (latest && data.versions[latest]) {
+		const version = data.versions[latest];
+		const versions = { [latest]: "latest" };
+		return {
+			name: version.name,
+			description: version.description,
+			[_verdaccio_core.DIST_TAGS]: { latest },
+			maintainers: version.maintainers || [version.author].filter(Boolean),
+			author: version.author,
+			repository: version.repository,
+			readmeFilename: version.readmeFilename || "",
+			homepage: version.homepage,
+			keywords: version.keywords,
+			bugs: version.bugs,
+			license: version.license,
+			versions
+		};
+	}
 }
-
 /**
- * Function gets a local info and an info from uplinks and tries to merge it
- exported for unit tests only.
-  * @param {*} cacheManifest
-  * @param {*} remoteManifest
-  */
+* Function gets a local info and an info from uplinks and tries to merge it
+exported for unit tests only.
+* @param {*} cacheManifest
+* @param {*} remoteManifest
+*/
 function mergeVersions(cacheManifest, remoteManifest) {
-  var _cacheManifest = _objectSpread({}, cacheManifest);
-  var versions = remoteManifest.versions,
-    time = remoteManifest.time;
-  // copy new versions to a cache
-  // NOTE: if a certain version was updated, we can't refresh it reliably
-  // however, we can refresh the deprecated status
-  for (var i in versions) {
-    if (typeof _cacheManifest.versions[i] === 'undefined') {
-      _cacheManifest.versions[i] = versions[i];
-    } else if (versions[i].deprecated) {
-      _cacheManifest.versions[i].deprecated = versions[i].deprecated;
-    }
-  }
-  for (var _i in time) {
-    if (typeof _cacheManifest.time[_i] === 'undefined') {
-      _cacheManifest.time[_i] = time[_i];
-    }
-  }
-  for (var distTag in remoteManifest[_core.DIST_TAGS]) {
-    if (_cacheManifest[_core.DIST_TAGS][distTag] !== remoteManifest[_core.DIST_TAGS][distTag]) {
-      if (!_cacheManifest[_core.DIST_TAGS][distTag] || _semver["default"].lte(_cacheManifest[_core.DIST_TAGS][distTag], remoteManifest[_core.DIST_TAGS][distTag])) {
-        _cacheManifest[_core.DIST_TAGS][distTag] = remoteManifest[_core.DIST_TAGS][distTag];
-      }
-      if (distTag === 'latest' && _cacheManifest[_core.DIST_TAGS][distTag] === remoteManifest[_core.DIST_TAGS][distTag]) {
-        // NOTE: this override the latest publish readme from local cache with
-        // the remote one
-        _cacheManifest = _objectSpread(_objectSpread({}, _cacheManifest), {}, {
-          readme: remoteManifest.readme
-        });
-      }
-    }
-  }
-  return _cacheManifest;
+	let _cacheManifest = { ...cacheManifest };
+	const { versions, time } = remoteManifest;
+	for (const i in versions) if (typeof _cacheManifest.versions[i] === "undefined") _cacheManifest.versions[i] = versions[i];
+	else if (versions[i].deprecated) _cacheManifest.versions[i].deprecated = versions[i].deprecated;
+	for (const i in time) if (typeof _cacheManifest.time[i] === "undefined") _cacheManifest.time[i] = time[i];
+	for (const distTag in remoteManifest[_verdaccio_core.DIST_TAGS]) if (_cacheManifest[_verdaccio_core.DIST_TAGS][distTag] !== remoteManifest[_verdaccio_core.DIST_TAGS][distTag]) {
+		if (!_cacheManifest[_verdaccio_core.DIST_TAGS][distTag] || semver.default.lte(_cacheManifest[_verdaccio_core.DIST_TAGS][distTag], remoteManifest[_verdaccio_core.DIST_TAGS][distTag])) _cacheManifest[_verdaccio_core.DIST_TAGS][distTag] = remoteManifest[_verdaccio_core.DIST_TAGS][distTag];
+		if (distTag === "latest" && _cacheManifest[_verdaccio_core.DIST_TAGS][distTag] === remoteManifest[_verdaccio_core.DIST_TAGS][distTag]) _cacheManifest = {
+			..._cacheManifest,
+			readme: remoteManifest.readme
+		};
+	}
+	return _cacheManifest;
 }
-
 /**
- * Normalize dist-tags.
- *
- * There is a legacy behaviour where the dist-tags could be an array, in such
- * case, the array is orderded and the highest version becames the
- * latest.
- *
- * The dist-tag tags must be plain strigs, if the latest is empty (for whatever reason) is
- * normalized to be the highest version available.
- *
- * This function cleans up every invalid version on dist-tags, but does not remove
- * invalid versions from the manifest.
- *
- * @param {*} data
- */
+* Normalize dist-tags.
+*
+* There is a legacy behaviour where the dist-tags could be an array, in such
+* case, the array is orderded and the highest version becames the
+* latest.
+*
+* The dist-tag tags must be plain strigs, if the latest is empty (for whatever reason) is
+* normalized to be the highest version available.
+*
+* This function cleans up every invalid version on dist-tags, but does not remove
+* invalid versions from the manifest.
+*
+* @param {*} data
+*/
 function normalizeDistTags(manifest) {
-  var sorted;
-  // handle missing latest dist-tag
-  if (!manifest[_core.DIST_TAGS].latest) {
-    var _sorted;
-    // if there is no latest tag, set the highest known version based on semver sort
-    sorted = (0, _versionsUtils.sortVersionsAndFilterInvalid)(Object.keys(manifest.versions));
-    if ((_sorted = sorted) !== null && _sorted !== void 0 && _sorted.length) {
-      // get the highest published version
-      manifest[_core.DIST_TAGS].latest = sorted.pop();
-    }
-  }
-  for (var tag in manifest[_core.DIST_TAGS]) {
-    // deprecated (will be removed un future majors)
-    // this should not happen, tags should be plain strings, legacy fallback
-    if (_lodash["default"].isArray(manifest[_core.DIST_TAGS][tag])) {
-      if (manifest[_core.DIST_TAGS][tag].length) {
-        // sort array
-        // FIXME: this is clearly wrong, we need to research why this is like this.
-        // @ts-ignore
-        sorted = (0, _versionsUtils.sortVersionsAndFilterInvalid)(manifest[_core.DIST_TAGS][tag]);
-        if (sorted.length) {
-          // use highest version based on semver sort
-          manifest[_core.DIST_TAGS][tag] = sorted.pop();
-        }
-      } else {
-        delete manifest[_core.DIST_TAGS][tag];
-      }
-    } else if (_lodash["default"].isString(manifest[_core.DIST_TAGS][tag])) {
-      if (!_semver["default"].parse(manifest[_core.DIST_TAGS][tag], true)) {
-        // if the version is invalid, delete the dist-tag entry
-        delete manifest[_core.DIST_TAGS][tag];
-      }
-    }
-  }
-  return manifest;
+	let sorted;
+	if (!manifest[_verdaccio_core.DIST_TAGS].latest) {
+		sorted = require_versions_utils.sortVersionsAndFilterInvalid(Object.keys(manifest.versions));
+		if (sorted?.length) manifest[_verdaccio_core.DIST_TAGS].latest = sorted.pop();
+	}
+	for (const tag in manifest[_verdaccio_core.DIST_TAGS]) if (lodash.default.isArray(manifest[_verdaccio_core.DIST_TAGS][tag])) if (manifest[_verdaccio_core.DIST_TAGS][tag].length) {
+		sorted = require_versions_utils.sortVersionsAndFilterInvalid(manifest[_verdaccio_core.DIST_TAGS][tag]);
+		if (sorted.length) manifest[_verdaccio_core.DIST_TAGS][tag] = sorted.pop();
+	} else delete manifest[_verdaccio_core.DIST_TAGS][tag];
+	else if (lodash.default.isString(manifest[_verdaccio_core.DIST_TAGS][tag])) {
+		if (!semver.default.parse(manifest[_verdaccio_core.DIST_TAGS][tag], true)) delete manifest[_verdaccio_core.DIST_TAGS][tag];
+	}
+	return manifest;
 }
 function hasDeprecatedVersions(pkgInfo) {
-  var versions = pkgInfo.versions;
-  for (var version in versions) {
-    if (Object.prototype.hasOwnProperty.call(versions[version], 'deprecated')) {
-      return true;
-    }
-  }
-  return false;
+	const { versions } = pkgInfo;
+	for (const version in versions) if (Object.prototype.hasOwnProperty.call(versions[version], "deprecated")) return true;
+	return false;
 }
 function isDeprecatedManifest(manifest) {
-  return hasDeprecatedVersions(manifest) && (typeof manifest._attachments === 'undefined' || Object.keys(manifest._attachments).length === 0);
+	return hasDeprecatedVersions(manifest) && (typeof manifest._attachments === "undefined" || Object.keys(manifest._attachments).length === 0);
 }
 function mapManifestToSearchPackageBody(pkg, searchItem) {
-  var latest = _core.pkgUtils.getLatest(pkg);
-  var version = pkg.versions[latest];
-  var result = {
-    name: version.name,
-    scope: '',
-    description: version.description,
-    version: latest,
-    keywords: version.keywords,
-    date: pkg.time[latest],
-    // FIXME: type
-    author: version.author,
-    // FIXME: not possible fill this out from a private package
-    publisher: {},
-    // FIXME: type
-    maintainers: version.maintainers,
-    links: {
-      npm: '',
-      homepage: version.homepage,
-      repository: version.repository,
-      bugs: version.bugs
-    }
-  };
-  if (typeof searchItem["package"].scoped === 'string') {
-    result.scope = searchItem["package"].scoped;
-  }
-  return result;
+	const latest = _verdaccio_core.pkgUtils.getLatest(pkg);
+	const version = pkg.versions[latest];
+	const result = {
+		name: version.name,
+		scope: "",
+		description: version.description,
+		version: latest,
+		keywords: version.keywords,
+		date: pkg.time[latest],
+		author: version.author,
+		publisher: {},
+		maintainers: version.maintainers,
+		links: {
+			npm: "",
+			homepage: version.homepage,
+			repository: version.repository,
+			bugs: version.bugs
+		}
+	};
+	if (typeof searchItem.package.scoped === "string") result.scope = searchItem.package.scoped;
+	return result;
 }
 function normalizeContributors(contributors) {
-  if (_lodash["default"].isNil(contributors)) {
-    return [];
-  } else if (contributors && _lodash["default"].isArray(contributors) === false) {
-    return [contributors];
-  } else if (_lodash["default"].isString(contributors)) {
-    return [{
-      name: contributors
-    }];
-  }
-  return contributors;
+	if (lodash.default.isNil(contributors)) return [];
+	else if (contributors && lodash.default.isArray(contributors) === false) return [contributors];
+	else if (lodash.default.isString(contributors)) return [{ name: contributors }];
+	return contributors;
 }
+//#endregion
+exports.STORAGE = STORAGE;
+exports.WHITELIST = WHITELIST;
+exports.checkPackageRemote = checkPackageRemote;
+exports.cleanUpLinksRef = cleanUpLinksRef;
+exports.cleanUpReadme = cleanUpReadme;
+exports.generatePackageTemplate = generatePackageTemplate;
+exports.generateRevision = generateRevision;
+exports.getLatestReadme = getLatestReadme;
+exports.hasDeprecatedVersions = hasDeprecatedVersions;
+exports.isDeprecatedManifest = isDeprecatedManifest;
+exports.mapManifestToSearchPackageBody = mapManifestToSearchPackageBody;
+exports.mergeUplinkTimeIntoLocal = mergeUplinkTimeIntoLocal;
+exports.mergeUplinkTimeIntoLocalNext = mergeUplinkTimeIntoLocalNext;
+exports.mergeVersions = mergeVersions;
+exports.normalizeContributors = normalizeContributors;
+exports.normalizeDistTags = normalizeDistTags;
+exports.normalizePackage = normalizePackage;
+exports.prepareSearchPackage = prepareSearchPackage;
+exports.updateUpLinkMetadata = updateUpLinkMetadata;
+
 //# sourceMappingURL=storage-utils.js.map