2.0.4

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @gitzone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitlab-ci.yml

@@ -1,127 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-    - npmci git mirror
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-audit:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=moderate
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - lossless
-    - docker
-    - priv
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  script:
-    - npmci command npm install -g tslint typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install lts
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
-      "type": "node",
+      "command": "npm test",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
+      "type": "node-terminal"
     }
   ]
 }

.vscode/settings.json

@@ -15,7 +15,7 @@
             "properties": {
               "projectType": {
                 "type": "string",
-                "enum": ["website", "element", "service", "npm"]
+                "enum": ["website", "element", "service", "npm", "wcc"]
               }
             }
           }

npmextra.json

@@ -7,10 +7,10 @@
     "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
-      "gitscope": "pushrocks",
+      "gitscope": "push.rocks",
       "gitrepo": "smartnpm",
-      "shortDescription": "interface with npm to retrieve package information",
-      "npmPackagename": "@pushrocks/smartnpm",
+      "description": "interface with npm to retrieve package information",
+      "npmPackagename": "@push.rocks/smartnpm",
       "license": "MIT"
     }
   }

package.json

@@ -1,32 +1,36 @@
 {
-  "name": "@pushrocks/smartnpm",
-  "version": "1.0.15",
+  "name": "@push.rocks/smartnpm",
+  "version": "2.0.4",
   "private": false,
   "description": "interface with npm to retrieve package information",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web --allowimplicitany)",
+    "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.22",
-    "@gitzone/tsrun": "^1.2.8",
-    "@gitzone/tstest": "^1.0.28",
-    "@pushrocks/tapbundle": "^3.2.1",
-    "@types/node": "^13.9.1",
-    "tslint": "^6.1.0",
-    "tslint-config-prettier": "^1.18.0"
+    "@gitzone/tsbuild": "^2.1.66",
+    "@gitzone/tsrun": "^1.2.44",
+    "@gitzone/tstest": "^1.0.77",
+    "@push.rocks/tapbundle": "^5.0.12",
+    "@types/node": "^20.4.4"
   },
   "dependencies": {
-    "@pushrocks/consolecolor": "^2.0.1",
-    "@pushrocks/smartarchive": "^1.0.12",
-    "@pushrocks/smartfile": "^7.0.11",
-    "@pushrocks/smartlog": "^2.0.21",
-    "@pushrocks/smartrequest": "^1.1.47",
-    "package-json": "^6.5.0"
+    "@push.rocks/consolecolor": "^2.0.1",
+    "@push.rocks/levelcache": "^3.0.6",
+    "@push.rocks/smartarchive": "^3.0.6",
+    "@push.rocks/smartfile": "^10.0.28",
+    "@push.rocks/smartpath": "^5.0.11",
+    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/smartrequest": "^2.0.18",
+    "@push.rocks/smarttime": "^4.0.4",
+    "@push.rocks/smartversion": "^3.0.2",
+    "package-json": "^8.1.1"
   },
   "files": [
     "ts/**/*",
@@ -39,5 +43,8 @@
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

readme.md

@@ -1,39 +1,37 @@
-# @pushrocks/smartnpm
+# @push.rocks/smartnpm
 interface with npm to retrieve package information
 
 ## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartnpm)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/smartnpm)
-* [github.com (source mirror)](https://github.com/pushrocks/smartnpm)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartnpm/)
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@push.rocks/smartnpm)
+* [gitlab.com (source)](https://gitlab.com/push.rocks/smartnpm)
+* [github.com (source mirror)](https://github.com/push.rocks/smartnpm)
+* [docs (typedoc)](https://push.rocks.gitlab.io/smartnpm/)
 
 ## Status for master
-[![pipeline status](https://gitlab.com/pushrocks/smartnpm/badges/master/pipeline.svg)](https://gitlab.com/pushrocks/smartnpm/commits/master)
-[![coverage report](https://gitlab.com/pushrocks/smartnpm/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartnpm/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartnpm.svg)](https://www.npmjs.com/package/@pushrocks/smartnpm)
-[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartnpm/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartnpm)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/push.rocks/smartnpm/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/smartnpm/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@push.rocks/smartnpm)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/push.rocks/smartnpm)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@push.rocks/smartnpm)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@push.rocks/smartnpm)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@push.rocks/smartnpm)](https://lossless.cloud)
 
 ## Usage
 
 Use TypeScript for best in class instellisense.
 
-For further information read the linked docs at the top of this README.
-
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
-
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
-
 ## Contribution
 
 We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
 
 For further information read the linked docs at the top of this readme.
 
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+## Legal
+> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
 | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
-
-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.ts

@@ -1,6 +1,6 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as smartnpm from '../ts/index';
-import { NpmRegistry } from '../ts/index';
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as smartnpm from '../ts/index.js';
+import { NpmRegistry } from '../ts/index.js';
 
 let npmRegistry: smartnpm.NpmRegistry;
 let verdaccioRegistry: smartnpm.NpmRegistry;
@@ -9,38 +9,53 @@ let testPackage: smartnpm.NpmPackage;
 // lets test things with the standard npm registry
 tap.test('should create valid instances', async () => {
   npmRegistry = new smartnpm.NpmRegistry();
-  expect(npmRegistry).to.be.instanceof(smartnpm.NpmRegistry);
+  expect(npmRegistry).toBeInstanceOf(smartnpm.NpmRegistry);
 
   testPackage = new smartnpm.NpmPackage(npmRegistry);
-  expect(testPackage).to.be.instanceof(smartnpm.NpmPackage);
+  expect(testPackage).toBeInstanceOf(smartnpm.NpmPackage);
 });
 
 tap.test('should produce a valid search string and this return npmts', async () => {
   const packages = await npmRegistry.searchOnNpm({
-    name: '@pushrocks/smartupdate'
+    name: '@pushrocks/smartupdate',
   });
-  expect(packages[0].name).to.equal('@pushrocks/smartupdate');
+  expect(packages[0].name).toEqual('@pushrocks/smartupdate');
 });
 
 // lets test things with the verdaccio registry
 tap.test('should create a verdaccio registry', async () => {
   verdaccioRegistry = new NpmRegistry({
-    npmRegistryUrl: 'https://verdaccio.lossless.one'
+    npmRegistryUrl: 'https://verdaccio.lossless.digital',
   });
-  expect(verdaccioRegistry).to.be.instanceOf(smartnpm.NpmRegistry);
+  expect(verdaccioRegistry).toBeInstanceOf(smartnpm.NpmRegistry);
 });
 
 tap.test('should get package from verdaccio', async () => {
   const npmPackage = await verdaccioRegistry.getPackageInfo('@pushrocks/smartupdate');
-  console.log(npmPackage);
-  expect(npmPackage.license).to.equal('MIT');
+  expect(npmPackage.license).toEqual('MIT');
 });
 
 tap.test('should get a specific file from a package', async () => {
-  const bundleFile = await verdaccioRegistry.getFileFromPackage(
+  const wantedFile = await verdaccioRegistry.getFileFromPackage(
     '@pushrocks/websetup',
-    'dist_bundle/bundle.js'
+    './ts/index.ts'
   );
+  console.log(wantedFile.contentBuffer.toString());
+});
+
+tap.test('should get a specific file from a package', async () => {
+  const wantedFiles = await verdaccioRegistry.getFilesFromPackage('@pushrocks/websetup', 'ts/');
+  for (const file of wantedFiles) {
+    console.log(file.path);
+  }
+});
+
+tap.test('should not get a nonexisting file from a package', async () => {
+  const wantedFileNotThere = await verdaccioRegistry.getFileFromPackage(
+    '@pushrocks/websetup',
+    'ts/notthere'
+  );
+  expect(wantedFileNotThere).toBeNull();
 });
 
 tap.start();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartnpm',
+  version: '2.0.4',
+  description: 'interface with npm to retrieve package information'
+}

ts/index.ts

@@ -1,4 +1,4 @@
-import * as plugins from './smartnpm.plugins';
+import * as plugins from './smartnpm.plugins.js';
 
-export * from './smartnpm.classes.npmregistry';
-export * from './smartnpm.classes.npmpackage';
+export * from './smartnpm.classes.npmregistry.js';
+export * from './smartnpm.classes.npmpackage.js';

ts/smartnpm.classes.npmpackage.ts

@@ -1,13 +1,35 @@
-import * as plugins from './smartnpm.plugins';
-import { NpmRegistry } from './smartnpm.classes.npmregistry';
+import * as plugins from './smartnpm.plugins.js';
+import { NpmRegistry } from './smartnpm.classes.npmregistry.js';
+import { PackageDisttag } from './smartnpm.classes.packagedisttag.js';
+import { PackageVersion, type IVersionData } from './smartnpm.classes.packageversion.js';
 
 export class NpmPackage {
-  public static async createFromFullMetadata(
+  public static async createFromFullMetadataAndVersionData(
     npmRegistryArg: NpmRegistry,
-    fullMetadata: plugins.packageJson.FullMetadata
+    fullMetadataArg: plugins.packageJson.FullMetadata,
+    versionsDataArg: {
+      name: string;
+      'dist-tags': { [key: string]: string };
+      versions: { [key: string]: IVersionData };
+    }
   ) {
     const npmPackage = new NpmPackage(npmRegistryArg);
-    Object.assign(npmPackage, fullMetadata);
+    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;
   }
 
@@ -15,6 +37,8 @@ export class NpmPackage {
   public name: string = null;
   public scope: string = null;
   public version: string = null;
+  public allVersions: PackageVersion[];
+  public allDistTags: PackageDisttag[];
   public description: string = null;
   public keywords: string[] = null;
   public date: string;
@@ -48,9 +72,9 @@ export class NpmPackage {
   } = null;
   public searchScore: number = null;
 
-  public npmRegistry: NpmRegistry;
+  public npmRegistryRef: NpmRegistry;
   constructor(npmRegistryArg: NpmRegistry) {
-    this.npmRegistry = npmRegistryArg;
+    this.npmRegistryRef = npmRegistryArg;
   }
 
   /**
@@ -58,6 +82,106 @@ export class NpmPackage {
    */
   public async saveToDisk(targetDir: string) {
     const smartarchiveInstance = new plugins.smartarchive.SmartArchive();
-    await smartarchiveInstance.extractArchiveFromUrl(this.dist.tarball, targetDir);
+    await smartarchiveInstance.extractArchiveFromUrlToFs(this.dist.tarball, targetDir);
+  }
+
+  /**
+   * saves the complete package to cache
+   */
+  public async saveToCache() {}
+
+  /**
+   * get files from package
+   */
+  public async getFilesFromPackage(
+    filePath: string,
+    optionsArg: {
+      distTag?: string;
+      version?: string;
+    },
+    returnOnFirstArg = false
+  ): Promise<plugins.smartfile.Smartfile[]> {
+    const done = plugins.smartpromise.defer<plugins.smartfile.Smartfile[]>();
+    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: string;
+      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: plugins.smartfile.Smartfile[] = [];
+    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
+   */
+  public async getFileFromPackage(
+    filePath: string,
+    optionsArg?: {
+      distTag?: string;
+      version?: string;
+    }
+  ): Promise<plugins.smartfile.Smartfile> {
+    const result = await this.getFilesFromPackage(filePath, optionsArg, true);
+    return result[0] || null;
+  }
+
+  /**
+   * updates the package with information from the registry
+   */
+  update() {}
+
+  /** */
+  public getBestMatchingVersion(versionArg: string): string {
+    // 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;
   }
 }

ts/smartnpm.classes.npmregistry.ts

@@ -1,11 +1,12 @@
-import * as plugins from './smartnpm.plugins';
-import * as paths from './smartnpm.paths';
+import * as plugins from './smartnpm.plugins.js';
+import * as paths from './smartnpm.paths.js';
 
 // interfaces
-import { ISearchObject } from './smartnpm.interfaces';
+import { type ISearchObject } from './smartnpm.interfaces.js';
 
 // classes
-import { NpmPackage } from './smartnpm.classes.npmpackage';
+import { NpmPackage } from './smartnpm.classes.npmpackage.js';
+import { type ICacheDescriptor, RegistryCache } from './smartnpm.classes.registrycache.js';
 
 export interface INpmRegistryConstructorOptions {
   npmRegistryUrl?: string;
@@ -13,17 +14,18 @@ export interface INpmRegistryConstructorOptions {
 
 export class NpmRegistry {
   public options: INpmRegistryConstructorOptions;
-  public registry: string;
+  public registryCache: RegistryCache;
   private searchDomain = 'https://api.npms.io/v2/search?q=';
 
   constructor(optionsArg: INpmRegistryConstructorOptions = {}) {
     const defaultOptions: INpmRegistryConstructorOptions = {
-      npmRegistryUrl: 'https://registry.npmjs.org'
+      npmRegistryUrl: 'https://registry.npmjs.org',
     };
     this.options = {
       ...defaultOptions,
-      ...optionsArg
+      ...optionsArg,
     };
+    this.registryCache = new RegistryCache(this);
   }
 
   /**
@@ -31,11 +33,24 @@ export class NpmRegistry {
    * @param packageName
    */
   public async getPackageInfo(packageName: string): Promise<NpmPackage> {
-    const fullMetadata = await plugins.packageJson(packageName, {
+    const fullMetadata = await plugins
+      .packageJson.default(packageName, {
+        registryUrl: this.options.npmRegistryUrl,
+        fullMetadata: true,
+      })
+      .catch((err) => {
+        console.log(err);
+        return null;
+      });
+    const versionData = await plugins.packageJson.default(packageName, {
       registryUrl: this.options.npmRegistryUrl,
-      fullMetadata: true
+      allVersions: true,
     });
-    const npmPackage = await NpmPackage.createFromFullMetadata(this, fullMetadata);
+    const npmPackage = await NpmPackage.createFromFullMetadataAndVersionData(
+      this,
+      fullMetadata,
+      versionData as any
+    );
     return npmPackage;
   }
 
@@ -45,6 +60,7 @@ export class NpmRegistry {
    * @param targetDir
    */
   public async savePackageToDisk(packageName: string, targetDir: string): Promise<void> {
+    plugins.smartfile.fs.ensureDirSync(paths.nogitDir);
     const npmPackage = await this.getPackageInfo(packageName);
     await npmPackage.saveToDisk(targetDir);
   }
@@ -52,15 +68,85 @@ export class NpmRegistry {
   /**
    * gets a file from a package as Smartfile
    */
-  public async getFileFromPackage(packageName: string, filePath: string) {
-    const baseDir = plugins.path.join(paths.nogitDir, packageName.replace('/', '__'));
-    await plugins.smartfile.fs.ensureDir(baseDir);
-    await this.savePackageToDisk(packageName, baseDir);
-    const smartfile = await plugins.smartfile.Smartfile.fromFilePath(
-      plugins.path.join(baseDir, 'package', filePath)
+  public async getFileFromPackage(
+    packageNameArg: string,
+    filePathArg: string,
+    optionsArg?: {
+      distTag?: string;
+      version?: string;
+    }
+  ): Promise<plugins.smartfile.Smartfile> {
+    // lets create a cache descriptor
+    const cacheDescriptor: ICacheDescriptor = {
+      registryUrl: this.options.npmRegistryUrl,
+      packageName: packageNameArg,
+      filePath: filePathArg,
+      distTag: optionsArg?.distTag,
+      version: optionsArg?.version,
+    };
+
+    // lets see if we have something cached
+    const cachedFile: plugins.smartfile.Smartfile = 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;
+    }
+  }
+
+  public async getFilesFromPackage(
+    packageNameArg: string,
+    filePath: string,
+    optionsArg?: {
+      distTag?: string;
+      version?: string;
+    }
+  ): Promise<plugins.smartfile.Smartfile[]> {
+    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);
+  }
+
+  public async getPackageAsSmartfileVirtualDir(
+    packageNameArg: string
+  ): Promise<plugins.smartfile.VirtualDirectory> {
+    /**
+     * 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 smartfile;
+    return virtualDir;
   }
 
   /**
@@ -134,9 +220,8 @@ export class NpmRegistry {
       addToSearchString(`author:${searchObjectArg.maintenanceWeight}`);
     }
 
-    plugins.smartlog.defaultLogger.log(
-      'info',
-      `Search on npm for ${plugins.consolecolor.coloredString(searchString, 'pink')}`
+    console.log(
+      `info: Search on npm for ${plugins.consolecolor.coloredString(searchString, 'pink')}`
     );
 
     let body: any;

ts/smartnpm.classes.packagedisttag.ts

@@ -0,0 +1,11 @@
+import * as plugins from './smartnpm.plugins.js';
+
+export class PackageDisttag {
+  name: string;
+  targetVersion: string;
+
+  constructor(nameArg: string, targetVersionArg: string) {
+    this.name = nameArg;
+    this.targetVersion = targetVersionArg;
+  }
+}

ts/smartnpm.classes.packageversion.ts

@@ -0,0 +1,31 @@
+import * as plugins from './smartnpm.plugins.js';
+
+export interface IVersionData {
+  name: string;
+  version: string;
+  dependencies: { [key: string]: string };
+  devDependencies: { [key: string]: string };
+  dist: {
+    integrity: string;
+    shasum: string;
+    tarball: string;
+  };
+}
+
+export class PackageVersion implements IVersionData {
+  public static createFromVersionData(versionDataArg: IVersionData) {
+    const packageVersion = new PackageVersion();
+    Object.assign(packageVersion, versionDataArg);
+    return packageVersion;
+  }
+
+  name: string;
+  version: string;
+  dependencies: { [key: string]: string };
+  devDependencies: { [key: string]: string };
+  dist: {
+    integrity: string;
+    shasum: string;
+    tarball: string;
+  };
+}

ts/smartnpm.classes.registrycache.ts

@@ -0,0 +1,63 @@
+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 class RegistryCache {
+  npmregistryRef: NpmRegistry;
+  public levelCache: plugins.levelcache.LevelCache;
+
+  constructor(npmRegistryRefArg: NpmRegistry) {
+    this.npmregistryRef = npmRegistryRefArg;
+    this.levelCache = new plugins.levelcache.LevelCache({
+      cacheId: encodeURIComponent(this.npmregistryRef.options.npmRegistryUrl),
+    });
+  }
+
+  public async getCachedFile(
+    cacheDescriptorArg: ICacheDescriptor
+  ): Promise<plugins.smartfile.Smartfile> {
+    const cacheEntry = await this.levelCache.retrieveCacheEntryByKey(
+      this.getCacheDescriptorAsString(cacheDescriptorArg)
+    );
+    if (cacheEntry) {
+      return plugins.smartfile.Smartfile.fromFoldedJson(cacheEntry.contents.toString());
+    }
+    return null;
+  }
+
+  public async cacheSmartFile(
+    cacheDescriptorArg: ICacheDescriptor,
+    smartfileArg: plugins.smartfile.Smartfile
+  ) {
+    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 }),
+        })
+      );
+    }
+  }
+
+  public getCacheDescriptorAsString(cacheDescriptorArg?: ICacheDescriptor) {
+    return `${cacheDescriptorArg.registryUrl}//+//${cacheDescriptorArg.packageName}//+//${
+      cacheDescriptorArg.filePath
+    }//+//${cacheDescriptorArg.distTag || cacheDescriptorArg.version}`;
+  }
+}

ts/smartnpm.paths.ts

@@ -1,5 +1,7 @@
-import * as plugins from './smartnpm.plugins';
+import * as plugins from './smartnpm.plugins.js';
 
-export const packageDir = plugins.path.join(__dirname, '../');
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
 export const nogitDir = plugins.path.join(packageDir, '.nogit/');
-plugins.smartfile.fs.ensureDirSync(nogitDir);

ts/smartnpm.plugins.ts

@@ -4,16 +4,29 @@ import * as path from 'path';
 export { path };
 
 // @pushrocks scope
-import * as consolecolor from '@pushrocks/consolecolor';
-import * as smartarchive from '@pushrocks/smartarchive';
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartlog from '@pushrocks/smartlog';
-smartlog.defaultLogger.enableConsole();
-import * as smartrequest from '@pushrocks/smartrequest';
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as levelcache from '@push.rocks/levelcache';
+import * as smartarchive from '@push.rocks/smartarchive';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartversion from '@push.rocks/smartversion';
+import * as smarttime from '@push.rocks/smarttime';
 
-export { consolecolor, smartarchive, smartfile, smartlog, smartrequest };
+export {
+  consolecolor,
+  levelcache,
+  smartarchive,
+  smartfile,
+  smartpath,
+  smartpromise,
+  smartrequest,
+  smartversion,
+  smarttime,
+};
 
 // third party scope
-import packageJson from 'package-json';
+import * as packageJson from 'package-json';
 
 export { packageJson };

tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext"
+  }
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}