@push.rocks/smartnpm 2.0.3

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smartnpm',
+    version: '2.0.3',
+    description: 'interface with npm to retrieve package information'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG9EQUFvRDtDQUNsRSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './smartnpm.classes.npmregistry.js';
+export * from './smartnpm.classes.npmpackage.js';

package/dist_ts/index.js

@@ -0,0 +1,4 @@
+import './smartnpm.plugins.js';
+export * from './smartnpm.classes.npmregistry.js';
+export * from './smartnpm.classes.npmpackage.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUF5Qix1QkFBdUIsQ0FBQztBQUVqRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsa0NBQWtDLENBQUMifQ==

package/dist_ts/smartnpm.classes.npmpackage.d.ts

@@ -0,0 +1,82 @@
+import * as plugins from './smartnpm.plugins.js';
+import { NpmRegistry } from './smartnpm.classes.npmregistry.js';
+import { PackageDisttag } from './smartnpm.classes.packagedisttag.js';
+import { PackageVersion, IVersionData } from './smartnpm.classes.packageversion.js';
+export declare class NpmPackage {
+    static createFromFullMetadataAndVersionData(npmRegistryArg: NpmRegistry, fullMetadataArg: plugins.packageJson.FullMetadata, versionsDataArg: {
+        name: string;
+        'dist-tags': {
+            [key: string]: string;
+        };
+        versions: {
+            [key: string]: IVersionData;
+        };
+    }): Promise<NpmPackage>;
+    name: string;
+    scope: string;
+    version: string;
+    allVersions: PackageVersion[];
+    allDistTags: PackageDisttag[];
+    description: string;
+    keywords: string[];
+    date: string;
+    license: string;
+    links: {
+        npm: string;
+        homepage: string;
+        repository: string;
+        bugs: string;
+    };
+    author: {
+        name: 'Lossless GmbH';
+    };
+    publisher: {
+        username: 'gitzone';
+        email: 'npm@git.zone';
+    };
+    maintainers: any;
+    dist: {
+        integrity: string;
+        shasum: string;
+        tarball: string;
+    };
+    score: {
+        final: number;
+        detail: {
+            quality: number;
+            popularity: number;
+            maintenance: number;
+        };
+    };
+    searchScore: number;
+    npmRegistryRef: NpmRegistry;
+    constructor(npmRegistryArg: NpmRegistry);
+    /**
+     * saves the package to disk
+     */
+    saveToDisk(targetDir: string): Promise<void>;
+    /**
+     * saves the complete package to cache
+     */
+    saveToCache(): Promise<void>;
+    /**
+     * get files from package
+     */
+    getFilesFromPackage(filePath: string, optionsArg: {
+        distTag?: string;
+        version?: string;
+    }, returnOnFirstArg?: boolean): Promise<plugins.smartfile.Smartfile[]>;
+    /**
+     * get files from package
+     */
+    getFileFromPackage(filePath: string, optionsArg?: {
+        distTag?: string;
+        version?: string;
+    }): Promise<plugins.smartfile.Smartfile>;
+    /**
+     * updates the package with information from the registry
+     */
+    update(): void;
+    /** */
+    getBestMatchingVersion(versionArg: string): string;
+}

package/dist_ts/smartnpm.classes.npmpackage.js

@@ -0,0 +1,118 @@
+import * as plugins from './smartnpm.plugins.js';
+import './smartnpm.classes.npmregistry.js';
+import { PackageDisttag } from './smartnpm.classes.packagedisttag.js';
+import { PackageVersion } from './smartnpm.classes.packageversion.js';
+export class NpmPackage {
+    constructor(npmRegistryArg) {
+        // INSTANCE
+        this.name = null;
+        this.scope = null;
+        this.version = null;
+        this.description = null;
+        this.keywords = null;
+        this.maintainers = null;
+        this.score = null;
+        this.searchScore = null;
+        this.npmRegistryRef = npmRegistryArg;
+    }
+    static async createFromFullMetadataAndVersionData(npmRegistryArg, fullMetadataArg, versionsDataArg) {
+        const npmPackage = new NpmPackage(npmRegistryArg);
+        Object.assign(npmPackage, fullMetadataArg);
+        npmPackage.allVersions = [];
+        npmPackage.allDistTags = [];
+        for (const versionArg of Object.keys(versionsDataArg.versions)) {
+            const packageVersion = PackageVersion.createFromVersionData(versionsDataArg.versions[versionArg]);
+            npmPackage.allVersions.push(packageVersion);
+        }
+        for (const distTagArg of Object.keys(versionsDataArg['dist-tags'])) {
+            const packageDistTag = new PackageDisttag(distTagArg, versionsDataArg['dist-tags'][distTagArg]);
+            npmPackage.allDistTags.push(packageDistTag);
+        }
+        return npmPackage;
+    }
+    /**
+     * saves the package to disk
+     */
+    async saveToDisk(targetDir) {
+        const smartarchiveInstance = new plugins.smartarchive.SmartArchive();
+        await smartarchiveInstance.extractArchiveFromUrlToFs(this.dist.tarball, targetDir);
+    }
+    /**
+     * saves the complete package to cache
+     */
+    async saveToCache() { }
+    /**
+     * get files from package
+     */
+    async getFilesFromPackage(filePath, optionsArg, returnOnFirstArg = false) {
+        const done = plugins.smartpromise.defer();
+        const smartarchiveInstance = new plugins.smartarchive.SmartArchive();
+        let tarballUrl = this.dist?.tarball;
+        if (optionsArg?.version || optionsArg?.distTag) {
+            if (optionsArg.distTag && optionsArg.version) {
+                throw new Error('Please either specify version OR disttag, not both.');
+            }
+            let targetVersionString;
+            if (optionsArg.distTag) {
+                const targetDistTag = this.allDistTags.find((distTag) => {
+                    return distTag.name === optionsArg.distTag;
+                });
+                if (targetDistTag) {
+                    targetVersionString = targetDistTag.targetVersion;
+                }
+            }
+            else {
+                targetVersionString = optionsArg.version;
+            }
+            // lets find the best matching release
+            const bestMatchingVersion = this.getBestMatchingVersion(targetVersionString);
+            if (!bestMatchingVersion) {
+                return null;
+            }
+            tarballUrl = this.allVersions.find((packageVersion) => packageVersion.version === bestMatchingVersion).dist.tarball;
+        }
+        const fileObservable = await smartarchiveInstance.extractArchiveFromUrlToObservable(tarballUrl);
+        const wantedFilePath = plugins.path.join('package', filePath);
+        const allMatchingFiles = [];
+        const subscription = fileObservable.subscribe((fileArg) => {
+            // returnOnFirstArg requires exact match
+            if (returnOnFirstArg && fileArg.path === wantedFilePath) {
+                // lets resolve with the wanted file
+                done.resolve([fileArg]);
+                subscription.unsubscribe();
+            }
+            else if (!returnOnFirstArg && fileArg.path.startsWith(wantedFilePath)) {
+                allMatchingFiles.push(fileArg);
+            }
+        }, (err) => {
+            console.log(err);
+        }, () => {
+            done.resolve(allMatchingFiles);
+            subscription.unsubscribe();
+        });
+        return done.promise;
+    }
+    /**
+     * get files from package
+     */
+    async getFileFromPackage(filePath, optionsArg) {
+        const result = await this.getFilesFromPackage(filePath, optionsArg, true);
+        return result[0] || null;
+    }
+    /**
+     * updates the package with information from the registry
+     */
+    update() { }
+    /** */
+    getBestMatchingVersion(versionArg) {
+        // lets find the best matching release
+        const targetVersion = plugins.smartversion.SmartVersion.fromFuzzyString(versionArg);
+        const versionStrings = this.allVersions.map((packageVersion) => packageVersion.version);
+        const bestMatchingVersion = targetVersion.getBestMatch(versionStrings);
+        if (!bestMatchingVersion) {
+            return null;
+        }
+        return bestMatchingVersion;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartnpm.classes.npmregistry.d.ts

@@ -0,0 +1,41 @@
+import * as plugins from './smartnpm.plugins.js';
+import { ISearchObject } from './smartnpm.interfaces.js';
+import { NpmPackage } from './smartnpm.classes.npmpackage.js';
+import { RegistryCache } from './smartnpm.classes.registrycache.js';
+export interface INpmRegistryConstructorOptions {
+    npmRegistryUrl?: string;
+}
+export declare class NpmRegistry {
+    options: INpmRegistryConstructorOptions;
+    registryCache: RegistryCache;
+    private searchDomain;
+    constructor(optionsArg?: INpmRegistryConstructorOptions);
+    /**
+     * gets info about a package
+     * @param packageName
+     */
+    getPackageInfo(packageName: string): Promise<NpmPackage>;
+    /**
+     * saves a package to disk
+     * @param packageName
+     * @param targetDir
+     */
+    savePackageToDisk(packageName: string, targetDir: string): Promise<void>;
+    /**
+     * gets a file from a package as Smartfile
+     */
+    getFileFromPackage(packageNameArg: string, filePathArg: string, optionsArg?: {
+        distTag?: string;
+        version?: string;
+    }): Promise<plugins.smartfile.Smartfile>;
+    getFilesFromPackage(packageNameArg: string, filePath: string, optionsArg?: {
+        distTag?: string;
+        version?: string;
+    }): Promise<plugins.smartfile.Smartfile[]>;
+    getPackageAsSmartfileVirtualDir(packageNameArg: string): Promise<plugins.smartfile.VirtualDirectory>;
+    /**
+     * searches for a package on npm
+     * @param searchObjectArg
+     */
+    searchOnNpm(searchObjectArg: ISearchObject): Promise<NpmPackage[]>;
+}

package/dist_ts/smartnpm.classes.npmregistry.js

@@ -0,0 +1,197 @@
+import * as plugins from './smartnpm.plugins.js';
+import * as paths from './smartnpm.paths.js';
+// interfaces
+import './smartnpm.interfaces.js';
+// classes
+import { NpmPackage } from './smartnpm.classes.npmpackage.js';
+import { RegistryCache } from './smartnpm.classes.registrycache.js';
+export class NpmRegistry {
+    constructor(optionsArg = {}) {
+        this.searchDomain = 'https://api.npms.io/v2/search?q=';
+        const defaultOptions = {
+            npmRegistryUrl: 'https://registry.npmjs.org',
+        };
+        this.options = {
+            ...defaultOptions,
+            ...optionsArg,
+        };
+        this.registryCache = new RegistryCache(this);
+    }
+    /**
+     * gets info about a package
+     * @param packageName
+     */
+    async getPackageInfo(packageName) {
+        const fullMetadata = await plugins.packageJson(packageName, {
+            registryUrl: this.options.npmRegistryUrl,
+            fullMetadata: true,
+        }).catch(err => {
+            console.log(err);
+            return null;
+        });
+        const versionData = await plugins.packageJson(packageName, {
+            registryUrl: this.options.npmRegistryUrl,
+            allVersions: true
+        });
+        const npmPackage = await NpmPackage.createFromFullMetadataAndVersionData(this, fullMetadata, versionData);
+        return npmPackage;
+    }
+    /**
+     * saves a package to disk
+     * @param packageName
+     * @param targetDir
+     */
+    async savePackageToDisk(packageName, targetDir) {
+        plugins.smartfile.fs.ensureDirSync(paths.nogitDir);
+        const npmPackage = await this.getPackageInfo(packageName);
+        await npmPackage.saveToDisk(targetDir);
+    }
+    /**
+     * gets a file from a package as Smartfile
+     */
+    async getFileFromPackage(packageNameArg, filePathArg, optionsArg) {
+        // lets create a cache descriptor
+        const cacheDescriptor = {
+            registryUrl: this.options.npmRegistryUrl,
+            packageName: packageNameArg,
+            filePath: filePathArg,
+            distTag: optionsArg?.distTag,
+            version: optionsArg?.version
+        };
+        // lets see if we have something cached
+        const cachedFile = await this.registryCache.getCachedFile(cacheDescriptor);
+        // lets handle both occasions
+        if (!cachedFile) {
+            const npmPackage = await this.getPackageInfo(packageNameArg);
+            if (!optionsArg?.version && !optionsArg?.distTag) {
+                const latestAvailable = npmPackage.allDistTags.find(packageArg => packageArg.name === 'latest');
+                if (!latestAvailable) {
+                    optionsArg = {
+                        version: npmPackage.getBestMatchingVersion('*')
+                    };
+                }
+            }
+            const fileResult = await npmPackage.getFileFromPackage(filePathArg, optionsArg);
+            if (fileResult) {
+                this.registryCache.cacheSmartFile(cacheDescriptor, fileResult);
+            }
+            return fileResult;
+        }
+        else {
+            return cachedFile;
+        }
+    }
+    async getFilesFromPackage(packageNameArg, filePath, optionsArg) {
+        const npmPackage = await this.getPackageInfo(packageNameArg);
+        if (!optionsArg?.version && !optionsArg?.distTag) {
+            const latestAvailable = npmPackage.allDistTags.find(packageDistTagArg => packageDistTagArg.name === 'latest');
+            if (!latestAvailable) {
+                optionsArg = {
+                    version: npmPackage.getBestMatchingVersion('*')
+                };
+            }
+        }
+        return npmPackage.getFilesFromPackage(filePath, optionsArg);
+    }
+    async getPackageAsSmartfileVirtualDir(packageNameArg) {
+        /**
+         * TODO: rewrite as memory only
+         */
+        const baseDir = plugins.path.join(paths.nogitDir, packageNameArg.replace('/', '__'));
+        await plugins.smartfile.fs.ensureDir(baseDir);
+        await this.savePackageToDisk(packageNameArg, baseDir);
+        const virtualDir = await plugins.smartfile.VirtualDirectory.fromFsDirPath(baseDir);
+        await plugins.smartfile.fs.remove(baseDir);
+        return virtualDir;
+    }
+    /**
+     * searches for a package on npm
+     * @param searchObjectArg
+     */
+    async searchOnNpm(searchObjectArg) {
+        if (this.options.npmRegistryUrl !== 'https://registry.npmjs.org') {
+            throw Error(`cannot search registries other than registry.gitlab.com`);
+        }
+        let searchString = '';
+        const addToSearchString = (addStringArg) => {
+            searchString = `${searchString}+${addStringArg}`;
+        };
+        // name
+        if (searchObjectArg.name) {
+            searchString = `${searchObjectArg.name}`;
+        }
+        // metadata
+        if (searchObjectArg.author) {
+            addToSearchString(`author:${searchObjectArg.author}`);
+        }
+        if (searchObjectArg.maintainer) {
+            addToSearchString(`maintainer:${searchObjectArg.maintainer}`);
+        }
+        if (searchObjectArg.scope) {
+            addToSearchString(`scope:${searchObjectArg.scope}`);
+        }
+        // status
+        if (searchObjectArg.deprecated) {
+            if (searchObjectArg.deprecated === true) {
+                addToSearchString(`is:deprecated`);
+            }
+            else {
+                addToSearchString(`not:deprecated`);
+            }
+        }
+        if (searchObjectArg.unstable) {
+            if (searchObjectArg.unstable === true) {
+                addToSearchString(`is:unstable`);
+            }
+            else {
+                addToSearchString(`not:unstable`);
+            }
+        }
+        if (searchObjectArg.insecure) {
+            if (searchObjectArg.insecure === true) {
+                addToSearchString(`is:insecure`);
+            }
+            else {
+                addToSearchString(`not:insecure`);
+            }
+        }
+        // search behaviour
+        if (searchObjectArg.boostExact) {
+            addToSearchString(`boost-exact:${searchObjectArg.boostExact}`);
+        }
+        if (searchObjectArg.scoreEffect) {
+            addToSearchString(`score-effect:${searchObjectArg.scoreEffect}`);
+        }
+        // analytics
+        if (searchObjectArg.qualityWeight) {
+            addToSearchString(`author:${searchObjectArg.qualityWeight}`);
+        }
+        if (searchObjectArg.popularityWeight) {
+            addToSearchString(`author:${searchObjectArg.popularityWeight}`);
+        }
+        if (searchObjectArg.maintenanceWeight) {
+            addToSearchString(`author:${searchObjectArg.maintenanceWeight}`);
+        }
+        console.log(`info: Search on npm for ${plugins.consolecolor.coloredString(searchString, 'pink')}`);
+        let body;
+        try {
+            const response = await plugins.smartrequest.getJson(this.searchDomain + searchString, {});
+            body = response.body;
+        }
+        catch {
+            // we do nothing
+        }
+        // lets create the packageArray
+        const packageArray = [];
+        // if request failed just return it empty
+        if (!body || typeof body === 'string') {
+            return packageArray;
+        }
+        for (const packageSearchInfoArg of body.results) {
+            const npmPackage = await this.getPackageInfo(packageSearchInfoArg.package.name);
+            packageArray.push(npmPackage);
+        }
+        return packageArray;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartnpm.classes.packagedisttag.d.ts

@@ -0,0 +1,5 @@
+export declare class PackageDisttag {
+    name: string;
+    targetVersion: string;
+    constructor(nameArg: string, targetVersionArg: string);
+}

package/dist_ts/smartnpm.classes.packagedisttag.js

@@ -0,0 +1,8 @@
+import './smartnpm.plugins.js';
+export class PackageDisttag {
+    constructor(nameArg, targetVersionArg) {
+        this.name = nameArg;
+        this.targetVersion = targetVersionArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRucG0uY2xhc3Nlcy5wYWNrYWdlZGlzdHRhZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0bnBtLmNsYXNzZXMucGFja2FnZWRpc3R0YWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBeUIsdUJBQXVCLENBQUM7QUFFakQsTUFBTSxPQUFPLGNBQWM7SUFJekIsWUFBWSxPQUFlLEVBQUUsZ0JBQXdCO1FBQ25ELElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxDQUFDO1FBQ3BCLElBQUksQ0FBQyxhQUFhLEdBQUcsZ0JBQWdCLENBQUM7SUFDeEMsQ0FBQztDQUNGIn0=

package/dist_ts/smartnpm.classes.packageversion.d.ts

@@ -0,0 +1,31 @@
+export interface IVersionData {
+    name: string;
+    version: string;
+    dependencies: {
+        [key: string]: string;
+    };
+    devDependencies: {
+        [key: string]: string;
+    };
+    dist: {
+        integrity: string;
+        shasum: string;
+        tarball: string;
+    };
+}
+export declare class PackageVersion implements IVersionData {
+    static createFromVersionData(versionDataArg: IVersionData): PackageVersion;
+    name: string;
+    version: string;
+    dependencies: {
+        [key: string]: string;
+    };
+    devDependencies: {
+        [key: string]: string;
+    };
+    dist: {
+        integrity: string;
+        shasum: string;
+        tarball: string;
+    };
+}

package/dist_ts/smartnpm.classes.packageversion.js

@@ -0,0 +1,9 @@
+import './smartnpm.plugins.js';
+export class PackageVersion {
+    static createFromVersionData(versionDataArg) {
+        const packageVersion = new PackageVersion();
+        Object.assign(packageVersion, versionDataArg);
+        return packageVersion;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRucG0uY2xhc3Nlcy5wYWNrYWdldmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0bnBtLmNsYXNzZXMucGFja2FnZXZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBeUIsdUJBQXVCLENBQUM7QUFjakQsTUFBTSxPQUFPLGNBQWM7SUFDbEIsTUFBTSxDQUFDLHFCQUFxQixDQUFDLGNBQTRCO1FBQzlELE1BQU0sY0FBYyxHQUFHLElBQUksY0FBYyxFQUFFLENBQUM7UUFDNUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxjQUFjLEVBQUUsY0FBYyxDQUFDLENBQUM7UUFDOUMsT0FBTyxjQUFjLENBQUM7SUFDeEIsQ0FBQztDQVdGIn0=

package/dist_ts/smartnpm.classes.registrycache.d.ts

@@ -0,0 +1,17 @@
+import { NpmRegistry } from './smartnpm.classes.npmregistry.js';
+import * as plugins from './smartnpm.plugins.js';
+export interface ICacheDescriptor {
+    registryUrl: string;
+    packageName: string;
+    filePath: string;
+    distTag?: string;
+    version?: string;
+}
+export declare class RegistryCache {
+    npmregistryRef: NpmRegistry;
+    levelCache: plugins.levelcache.LevelCache;
+    constructor(npmRegistryRefArg: NpmRegistry);
+    getCachedFile(cacheDescriptorArg: ICacheDescriptor): Promise<plugins.smartfile.Smartfile>;
+    cacheSmartFile(cacheDescriptorArg: ICacheDescriptor, smartfileArg: plugins.smartfile.Smartfile): Promise<void>;
+    getCacheDescriptorAsString(cacheDescriptorArg?: ICacheDescriptor): string;
+}

package/dist_ts/smartnpm.classes.registrycache.js

@@ -0,0 +1,35 @@
+import './smartnpm.classes.npmregistry.js';
+import * as plugins from './smartnpm.plugins.js';
+export class RegistryCache {
+    constructor(npmRegistryRefArg) {
+        this.npmregistryRef = npmRegistryRefArg;
+        this.levelCache = new plugins.levelcache.LevelCache({
+            cacheId: encodeURIComponent(this.npmregistryRef.options.npmRegistryUrl),
+        });
+    }
+    async getCachedFile(cacheDescriptorArg) {
+        const cacheEntry = await this.levelCache.retrieveCacheEntryByKey(this.getCacheDescriptorAsString(cacheDescriptorArg));
+        if (cacheEntry) {
+            return plugins.smartfile.Smartfile.fromFoldedJson(cacheEntry.contents.toString());
+        }
+        return null;
+    }
+    async cacheSmartFile(cacheDescriptorArg, smartfileArg) {
+        if (smartfileArg && cacheDescriptorArg.version) {
+            await this.levelCache.storeCacheEntryByKey(this.getCacheDescriptorAsString(cacheDescriptorArg), new plugins.levelcache.CacheEntry({
+                contents: Buffer.from(smartfileArg.foldToJson()),
+                ttl: plugins.smarttime.getMilliSecondsFromUnits({ hours: 1 })
+            }));
+        }
+        else {
+            await this.levelCache.storeCacheEntryByKey(this.getCacheDescriptorAsString(cacheDescriptorArg), new plugins.levelcache.CacheEntry({
+                contents: Buffer.from(smartfileArg.foldToJson()),
+                ttl: plugins.smarttime.getMilliSecondsFromUnits({ minutes: 1 })
+            }));
+        }
+    }
+    getCacheDescriptorAsString(cacheDescriptorArg) {
+        return `${cacheDescriptorArg.registryUrl}//+//${cacheDescriptorArg.packageName}//+//${cacheDescriptorArg.filePath}//+//${cacheDescriptorArg.distTag || cacheDescriptorArg.version}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartnpm.interfaces.d.ts

@@ -0,0 +1,15 @@
+export interface ISearchObject {
+    name?: string;
+    author?: string;
+    maintainer?: string;
+    scope?: string;
+    keywords?: string[];
+    deprecated?: boolean;
+    unstable?: boolean;
+    insecure?: boolean;
+    boostExact?: boolean;
+    scoreEffect?: number;
+    qualityWeight?: number;
+    popularityWeight?: number;
+    maintenanceWeight?: number;
+}

package/dist_ts/smartnpm.interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRucG0uaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0bnBtLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/smartnpm.paths.d.ts

@@ -0,0 +1,2 @@
+export declare const packageDir: string;
+export declare const nogitDir: string;

package/dist_ts/smartnpm.paths.js

@@ -0,0 +1,4 @@
+import * as plugins from './smartnpm.plugins.js';
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+export const nogitDir = plugins.path.join(packageDir, '.nogit/');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRucG0ucGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydG5wbS5wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHVCQUF1QixDQUFDO0FBRWpELE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyx3QkFBd0IsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDO0FBQ3BILE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsU0FBUyxDQUFDLENBQUMifQ==

package/dist_ts/smartnpm.plugins.d.ts

@@ -0,0 +1,14 @@
+import * as path from 'path';
+export { path };
+import * as consolecolor from '@pushrocks/consolecolor';
+import * as levelcache from '@pushrocks/levelcache';
+import * as smartarchive from '@pushrocks/smartarchive';
+import * as smartfile from '@pushrocks/smartfile';
+import * as smartpath from '@pushrocks/smartpath';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartversion from '@pushrocks/smartversion';
+import * as smarttime from '@pushrocks/smarttime';
+export { consolecolor, levelcache, smartarchive, smartfile, smartpath, smartpromise, smartrequest, smartversion, smarttime };
+import packageJson from 'package-json';
+export { packageJson };