Compare commits

21 Commits

Author SHA1 Message Date
1f2937b387 update 2025-11-03 16:02:12 +00:00
4823eb9082 update 2025-11-03 16:01:58 +00:00
39eda12a39 update description 2024-05-29 14:16:58 +02:00
f56c9bc371 update tsconfig 2024-04-14 18:30:39 +02:00
586db93aa3 update tsconfig 2024-04-01 21:42:02 +02:00
ff10fbd0b5 update npmextra.json: githost 2024-04-01 19:59:59 +02:00
756c6fd26b update npmextra.json: githost 2024-03-30 21:48:59 +01:00
16e58bbbc2 2.0.6 2023-07-26 20:51:48 +02:00
8ffdf58d68 fix(core): update 2023-07-26 20:51:47 +02:00
2abac29dff 2.0.5 2023-07-26 20:51:12 +02:00
293da8859d fix(core): update 2023-07-26 20:51:11 +02:00
111ef1fe44 2.0.4 2022-06-01 20:29:14 +02:00
97b285be5c fix(core): update 2022-06-01 20:29:13 +02:00
cc659a57f7 2.0.3 2022-04-13 16:54:41 +02:00
f5cb86b53e fix(core): update 2022-04-13 16:54:40 +02:00
207f1e9d51 2.0.2 2022-04-13 16:20:55 +02:00
750b029ef8 update 2022-04-13 16:20:51 +02:00
710fd5ec2e 2.0.1 2022-04-13 16:15:26 +02:00
d1315392a1 update 2022-04-13 16:15:23 +02:00
cf894d9e82 2.0.0 2022-04-13 16:02:33 +02:00
1da4e08ed2 BREAKING CHANGE(core): switch to esm 2022-04-13 16:02:29 +02:00
25 changed files with 17101 additions and 6604 deletions

View File

@@ -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

View File

@@ -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

View File

@@ -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=high
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

24
.vscode/launch.json vendored
View File

@@ -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"
}
]
}

View File

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

7198
deno.lock generated Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -6,12 +6,27 @@
"gitzone": {
"projectType": "npm",
"module": {
"githost": "gitlab.com",
"gitscope": "pushrocks",
"githost": "code.foss.global",
"gitscope": "push.rocks",
"gitrepo": "smartupdate",
"shortDescription": "update your tools in a smart way",
"npmPackagename": "@pushrocks/smartupdate",
"license": "MIT"
}
"description": "A library designed to facilitate smarter update notifications and checking for Node.js projects.",
"npmPackagename": "@push.rocks/smartupdate",
"license": "MIT",
"keywords": [
"update notifications",
"version checking",
"npm package updates",
"version comparison",
"CLI tool updates",
"dependency management",
"npm registry",
"typescript utilities",
"software maintenance",
"open-source contribution"
]
}
},
"tsdoc": {
"legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
}
}

6267
package-lock.json generated

File diff suppressed because it is too large Load Diff

View File

@@ -1,32 +1,31 @@
{
"name": "@pushrocks/smartupdate",
"version": "1.0.31",
"name": "@push.rocks/smartupdate",
"version": "2.0.6",
"private": false,
"description": "update your tools in a smart way",
"description": "A library designed to facilitate smarter update notifications and checking for Node.js projects.",
"main": "dist_ts/index.js",
"typings": "dist_ts/index.d.ts",
"type": "module",
"author": "Lossless GmbH",
"license": "MIT",
"scripts": {
"test": "(tstest test/)",
"build": "(tsbuild --web)"
"test": "(tstest test/ --verbose)",
"build": "(tsbuild --web --allowimplicitany)",
"buildDocs": "tsdoc"
},
"devDependencies": {
"@gitzone/tsbuild": "^2.1.24",
"@gitzone/tsrun": "^1.2.12",
"@gitzone/tstest": "^1.0.33",
"@pushrocks/tapbundle": "^3.2.1",
"@types/node": "^14.0.14",
"tslint": "^6.1.2",
"tslint-config-prettier": "^1.18.0"
"@git.zone/tsbuild": "^2.7.1",
"@git.zone/tsrun": "^1.6.2",
"@git.zone/tstest": "^2.7.0",
"@types/node": "^22.19.0"
},
"dependencies": {
"@pushrocks/consolecolor": "^2.0.1",
"@pushrocks/npmextra": "^3.0.7",
"@pushrocks/smartnpm": "^1.0.17",
"@pushrocks/smartopen": "^1.0.22",
"@pushrocks/smarttime": "^3.0.18",
"@pushrocks/smartversion": "^2.0.4"
"@push.rocks/consolecolor": "^2.0.3",
"@push.rocks/npmextra": "^5.3.3",
"@push.rocks/smartnpm": "^2.0.6",
"@push.rocks/smartopen": "^2.0.0",
"@push.rocks/smarttime": "^4.1.1",
"@push.rocks/smartversion": "^3.0.5"
},
"files": [
"ts/**/*",
@@ -39,5 +38,26 @@
"cli.js",
"npmextra.json",
"readme.md"
]
],
"browserslist": [
"last 1 chrome versions"
],
"keywords": [
"update notifications",
"version checking",
"npm package updates",
"version comparison",
"CLI tool updates",
"dependency management",
"npm registry",
"typescript utilities",
"software maintenance",
"open-source contribution"
],
"homepage": "https://code.foss.global/push.rocks/smartupdate",
"repository": {
"type": "git",
"url": "https://code.foss.global/push.rocks/smartupdate.git"
},
"packageManager": "pnpm@10.18.1+sha512.77a884a165cbba2d8d1c19e3b4880eee6d2fcabd0d879121e282196b80042351d5eb3ca0935fa599da1dc51265cc68816ad2bddd2a2de5ea9fdf92adbec7cd34"
}

8570
pnpm-lock.yaml generated Normal file

File diff suppressed because it is too large Load Diff

1
readme.hints.md Normal file
View File

@@ -0,0 +1 @@

118
readme.md
View File

@@ -1,53 +1,99 @@
# @pushrocks/smartupdate
# @push.rocks/smartupdate
update your tools in a smart way
## Availabililty and Links
* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartupdate)
* [gitlab.com (source)](https://gitlab.com/pushrocks/smartupdate)
* [github.com (source mirror)](https://github.com/pushrocks/smartupdate)
* [docs (typedoc)](https://pushrocks.gitlab.io/smartupdate/)
## Install
To get started with `@push.rocks/smartupdate`, you need to install it via npm. Run the following command in your terminal:
## Status for master
```bash
npm install @push.rocks/smartupdate --save
```
Status Category | Status Badge
-- | --
GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartupdate/badges/master/pipeline.svg)](https://lossless.cloud)
GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartupdate/badges/master/coverage.svg)](https://lossless.cloud)
npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartupdate)](https://lossless.cloud)
Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartupdate)](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/@pushrocks/smartupdate)](https://lossless.cloud)
PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartupdate)](https://lossless.cloud)
BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartupdate)](https://lossless.cloud)
Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
This will add `@push.rocks/smartupdate` as a dependency to your project and download it to your `node_modules` folder.
## Usage
Use TypeScript for best in class instellisense.
The `@push.rocks/smartupdate` module offers a smart way to notify users of your CLI tools or libraries about new versions available on npm. Let's take a closer look at how you can utilize it in your project using TypeScript.
smartupdate makes it really easy to notify your tool users about new versions:
### Importing and Instantiating `SmartUpdate`
First, you need to import the `SmartUpdate` class from the `@push.rocks/smartupdate` package and create an instance of it. You can optionally pass settings to the constructor to customize its behavior:
```typescript
import * as smartupdate from 'smartupdate';
import { SmartUpdate } from '@push.rocks/smartupdate';
// the following command will check npm for a version newer than the specified one.
// It will open the specified URL if a newer version is actually found.
await smartupdate.standardHandler.check(
'lodash',
'1.0.5',
'http://gitzone.gitlab.io/npmts/changelog.html'
);
const smartUpdate = new SmartUpdate();
```
## Contribution
### Checking for Updates
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). :)
To check for an update for a specific npm package, you can use the `check` method. This method requires the npm package name, the current local version of the package you are checking against, and optionally, a URL to the changelog. If a newer version is found, it will log a message to the console and, if a changelog URL is provided and not running in a CI environment, attempt to open the changelog in the default web browser.
For further information read the linked docs at the top of this readme.
Heres an example:
> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
```typescript
// Async function to demonstrate usage
async function checkForUpdates() {
const npmPackageName = 'some-npm-package';
const currentVersion = '1.0.0';
const changelogUrl = 'https://example.com/changelog';
[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
// Check for an update for 'some-npm-package'
const hasNewerVersion = await smartUpdate.check(npmPackageName, currentVersion, changelogUrl);
if (hasNewerVersion) {
console.log('A newer version is available. Please consider updating.');
} else {
console.log('You are using the latest version.');
}
}
// Execute the function
checkForUpdates().catch(console.error);
```
### Checking for CLI Updates
For CLI applications, `@push.rocks/smartupdate` offers a more tailored method called `checkForCli`. This method works similarly to `check` but is optimized for CLI tools, taking into account factors like avoiding frequent checks (e.g., not more than once per hour).
Example usage:
```typescript
// Async function to demonstrate CLI update checks
async function checkCliUpdates() {
const cliPackageName = 'your-cli-tool';
const currentCliVersion = '0.1.0';
const changelogUrl = 'https://example.com/cli-changelog';
const needsUpdate = await smartUpdate.checkForCli(cliPackageName, currentCliVersion, changelogUrl);
if (needsUpdate) {
console.log(`A newer version of ${cliPackageName} is available. Visit ${changelogUrl} for more information.`);
} else {
console.log(`You are using the latest version of ${cliPackageName}.`);
}
}
// Run the CLI update check
checkCliUpdates().catch(console.error);
```
By integrating `@push.rocks/smartupdate` into your project, you ensure users are always informed about the latest updates, encouraging them to keep their installations current and benefiting from new features, performance improvements, and bug fixes.
## License and Legal Information
This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository.
**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
### Trademarks
This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
### Company Information
Task Venture Capital GmbH
Registered at District court Bremen HRB 35230 HB, Germany
For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

127
test/test.node+bun+deno.ts Normal file
View File

@@ -0,0 +1,127 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as smartupdate from '../ts/index.js';
let testSmartUpdate: smartupdate.SmartUpdate;
let silentSmartUpdate: smartupdate.SmartUpdate;
// Test suite for backward compatibility
tap.test('backward compatibility: should create an instance of SmartUpdate', async () => {
testSmartUpdate = new smartupdate.SmartUpdate();
expect(testSmartUpdate).toBeInstanceOf(smartupdate.SmartUpdate);
});
tap.test('backward compatibility: should check for a npm module using old API', async () => {
const result = await testSmartUpdate.check('lodash', '1.0.5');
expect(result).toBeTrue();
});
// Test suite for new modern API
tap.test('modern API: should create SmartUpdate with custom options', async () => {
silentSmartUpdate = new smartupdate.SmartUpdate({
logLevel: 'SILENT',
noColor: true,
cacheDuration: { minutes: 30 },
});
expect(silentSmartUpdate).toBeInstanceOf(smartupdate.SmartUpdate);
});
tap.test('modern API: checkForUpdate should return rich result object', async () => {
const result = await silentSmartUpdate.checkForUpdate({
packageName: 'lodash',
currentVersion: '1.0.0',
cacheStrategy: 'never',
});
// Verify result structure
expect(result).toBeTypeOf('object');
expect(result.status).toBeTypeOf('string');
expect(result.packageName).toEqual('lodash');
expect(result.currentVersion).toEqual('1.0.0');
expect(result.checkTime).toBeInstanceOf(Date);
expect(result.cacheHit).toBeTypeOf('boolean');
// Should have update available (1.0.0 is old)
expect(result.status).toEqual('update-available');
expect(result.latestVersion).toBeTypeOf('string');
});
tap.test('modern API: checkForUpdate with up-to-date version', async () => {
const result = await silentSmartUpdate.checkForUpdate({
packageName: '@push.rocks/smartversion',
currentVersion: '999.999.999', // Future version
cacheStrategy: 'never',
});
expect(result.status).toEqual('up-to-date');
expect(result.latestVersion).toBeTypeOf('string');
});
tap.test('modern API: getLatestVersion utility method', async () => {
const latestVersion = await silentSmartUpdate.getLatestVersion('lodash');
expect(latestVersion).toBeTypeOf('string');
expect(latestVersion).toMatch(/^\d+\.\d+\.\d+/); // Semver format
});
tap.test('modern API: error handling for non-existent package', async () => {
const result = await silentSmartUpdate.checkForUpdate({
packageName: 'this-package-definitely-does-not-exist-12345',
currentVersion: '1.0.0',
cacheStrategy: 'never',
});
expect(result.status).toEqual('error');
expect(result.error).toBeInstanceOf(Error);
});
tap.test('modern API: cache strategy works', async () => {
// Clear cache first to ensure clean state
const testPackage = 'express';
try {
await silentSmartUpdate.clearCache(testPackage);
} catch (e) {
// Cache might not exist, that's fine
}
// First check - should hit registry with 'never' strategy
const result1 = await silentSmartUpdate.checkForUpdate({
packageName: testPackage,
currentVersion: '1.0.0',
cacheStrategy: 'never',
});
expect(result1.cacheHit).toBeFalse();
expect(result1.status).toEqual('update-available');
// Do a second check with time-based that will create cache
const result2 = await silentSmartUpdate.checkForUpdate({
packageName: testPackage,
currentVersion: '1.0.0',
cacheStrategy: 'time-based',
});
// Third immediate check - should use cache with 'always' strategy
const result3 = await silentSmartUpdate.checkForUpdate({
packageName: testPackage,
currentVersion: '1.0.0',
cacheStrategy: 'always',
});
expect(result3.cacheHit).toBeTrue();
expect(result3.status).toEqual('check-skipped');
// nextCheckTime may or may not be set depending on cache strategy implementation
if (result3.nextCheckTime) {
expect(result3.nextCheckTime).toBeInstanceOf(Date);
}
});
tap.test('modern API: exports all types and classes', () => {
// Verify exports
expect(smartupdate.SmartUpdate).toBeTypeOf('function');
expect(smartupdate.UpdateCacheManager).toBeTypeOf('function');
expect(smartupdate.UpdateNotifier).toBeTypeOf('function');
expect(smartupdate.RegistryUnavailableError).toBeTypeOf('function');
expect(smartupdate.PackageNotFoundError).toBeTypeOf('function');
expect(smartupdate.LOG_LEVELS).toBeTypeOf('object');
});
export default tap.start();

View File

@@ -1,14 +0,0 @@
import { expect, tap } from '@pushrocks/tapbundle';
import * as smartupdate from '../ts/index';
let testSmartUpdate: smartupdate.SmartUpdate;
tap.test('should create an instance of SmartUpdate', async () => {
testSmartUpdate = new smartupdate.SmartUpdate();
});
tap.test('should check for a npm module', async () => {
await testSmartUpdate.check('lodash', '1.0.5');
});
tap.start();

8
ts/00_commitinfo_data.ts Normal file
View File

@@ -0,0 +1,8 @@
/**
* autocreated commitinfo by @pushrocks/commitinfo
*/
export const commitinfo = {
name: '@push.rocks/smartupdate',
version: '2.0.6',
description: 'update your tools in a smart way'
}

View File

@@ -1 +1,29 @@
export { SmartUpdate } from './smartupdate.classes.smartupdate';
// Main class
export { SmartUpdate } from './smartupdate.classes.smartupdate.js';
// Supporting classes (for advanced use cases)
export { UpdateCacheManager } from './smartupdate.classes.cachemanager.js';
export { UpdateNotifier } from './smartupdate.classes.notifier.js';
// Interfaces and types
export type {
ISmartUpdateOptions,
IUpdateCheckOptions,
IUpdateCheckResult,
ICacheStatus,
ICacheOptions,
INotificationOptions,
} from './smartupdate.interfaces.js';
// Error classes
export {
SmartUpdateError,
RegistryUnavailableError,
PackageNotFoundError,
InvalidVersionError,
InvalidPackageNameError,
} from './smartupdate.errors.js';
// Constants (for reference)
export type { TLogLevel } from './smartupdate.constants.js';
export { LOG_LEVELS, DEFAULT_MESSAGE_COLOR } from './smartupdate.constants.js';

View File

@@ -0,0 +1,116 @@
import * as plugins from './smartupdate.plugins.js';
import type { ICacheStatus, ICacheOptions } from './smartupdate.interfaces.js';
/**
* Manages caching of update check results
*/
export class UpdateCacheManager {
private kvStore: plugins.npmextra.KeyValueStore;
private cacheDurationMs: number;
constructor(options: ICacheOptions) {
this.cacheDurationMs = options.durationMs;
this.kvStore = new plugins.npmextra.KeyValueStore({
typeArg: 'userHomeDir',
identityArg: options.storeIdentifier || 'global_smartupdate',
});
}
/**
* Get the cache duration in milliseconds
*/
public getCacheDuration(): number {
return this.cacheDurationMs;
}
/**
* Get cached status for a package
*/
public async getCached(packageName: string): Promise<ICacheStatus | null> {
return await this.kvStore.readKey(packageName);
}
/**
* Set cache status for a package
*/
public async setCached(packageName: string, status: ICacheStatus): Promise<void> {
await this.kvStore.writeKey(packageName, status);
}
/**
* Clear cache for a specific package or all packages
*/
public async clearCache(packageName?: string): Promise<void> {
if (packageName) {
await this.kvStore.deleteKey(packageName);
} else {
// Clear all keys - this requires reading all keys first
// For now, we'll skip implementing full cache clear as it requires more kvStore API
throw new Error('Clearing all cache entries is not yet implemented');
}
}
/**
* Check if we should check the registry or use cache
* @returns Object with shouldCheck flag and optional nextCheckTime
*/
public async shouldCheckRegistry(
packageName: string,
strategy: 'always' | 'never' | 'time-based' = 'time-based'
): Promise<{
shouldCheck: boolean;
cacheStatus?: ICacheStatus;
nextCheckTime?: Date;
minutesUntilNextCheck?: number;
}> {
// Never use cache
if (strategy === 'never') {
return { shouldCheck: true };
}
// Get cached data
const cacheStatus = await this.getCached(packageName);
// No cache exists
if (!cacheStatus) {
return { shouldCheck: true };
}
// Always use cache if available
if (strategy === 'always') {
return { shouldCheck: false, cacheStatus };
}
// Time-based strategy: check if cache is still valid
const now = Date.now();
const lastCheckTime = cacheStatus.lastCheck;
const timeSinceLastCheck = now - lastCheckTime;
// Cache is still valid
if (timeSinceLastCheck < this.cacheDurationMs) {
const nextCheckTime = new Date(lastCheckTime + this.cacheDurationMs);
const minutesUntilNextCheck = (this.cacheDurationMs - timeSinceLastCheck) / 60000;
return {
shouldCheck: false,
cacheStatus,
nextCheckTime,
minutesUntilNextCheck,
};
}
// Cache is expired
return { shouldCheck: true, cacheStatus };
}
/**
* Create a new cache status object
*/
public createCacheStatus(latestVersion: string, performedUpgrade: boolean = false): ICacheStatus {
return {
lastCheck: Date.now(),
latestVersion,
performedUpgrade,
};
}
}

View File

@@ -0,0 +1,169 @@
import * as plugins from './smartupdate.plugins.js';
import {
LOG_LEVELS,
type TLogLevel,
DEFAULT_MESSAGE_COLOR,
MESSAGE_PREFIXES,
} from './smartupdate.constants.js';
import type { INotificationOptions, IUpdateCheckResult } from './smartupdate.interfaces.js';
/**
* Handles all user-facing notifications and console output
*/
export class UpdateNotifier {
private logLevel: TLogLevel;
private useColors: boolean;
private customLogger?: (level: TLogLevel, message: string) => void;
constructor(options: INotificationOptions) {
this.logLevel = options.logLevel;
this.useColors = options.useColors && !process.env.NO_COLOR;
this.customLogger = options.customLogger;
}
/**
* Check if a message at the given level should be logged
*/
private shouldLog(level: TLogLevel): boolean {
return LOG_LEVELS[level] <= LOG_LEVELS[this.logLevel];
}
/**
* Colorize a string if colors are enabled
*/
private colorize(text: string, color: any = DEFAULT_MESSAGE_COLOR): string {
if (!this.useColors) {
return text;
}
return plugins.consolecolor.coloredString(text, color as any);
}
/**
* Log a message at the specified level
*/
private log(level: TLogLevel, message: string): void {
if (!this.shouldLog(level)) {
return;
}
if (this.customLogger) {
this.customLogger(level, message);
} else {
console.log(message);
}
}
/**
* Log a debug message
*/
public debug(message: string): void {
this.log('DEBUG', `${MESSAGE_PREFIXES.INFO} ${message}`);
}
/**
* Log an info message
*/
public info(message: string): void {
this.log('INFO', `${MESSAGE_PREFIXES.SMARTUPDATE} ${message}`);
}
/**
* Log a warning message
*/
public warn(message: string): void {
this.log('WARN', `${MESSAGE_PREFIXES.WARN} ${message}`);
}
/**
* Log an error message
*/
public error(message: string): void {
this.log('ERROR', `${MESSAGE_PREFIXES.ERROR} ${message}`);
}
/**
* Notify about checking for updates
*/
public notifyCheckingForUpdate(packageName: string): void {
this.info(
`checking for newer version of ${this.colorize(packageName)}...`
);
}
/**
* Notify that the package is up to date
*/
public notifyUpToDate(packageName: string): void {
this.info(
`You are running the latest version of ${this.colorize(packageName)}`
);
}
/**
* Notify that an update is available
*/
public notifyUpdateAvailable(packageName: string, currentVersion: string, latestVersion: string): void {
this.warn(`There is a newer version of ${packageName} available on npm.`);
this.warn(`Your version: ${currentVersion} | version on npm: ${latestVersion}`);
}
/**
* Notify that a check was skipped due to rate limiting
*/
public notifyCheckSkipped(packageName: string, nextCheckMinutes: number): void {
const minutes = Math.floor(nextCheckMinutes) + 1;
this.info(
`Already checked recently. Next check available in ${minutes} minute${minutes !== 1 ? 's' : ''}: ` +
this.colorize(packageName)
);
}
/**
* Notify that the changelog is being opened
*/
public notifyOpeningChangelog(): void {
this.info('Opening changelog in browser...');
}
/**
* Notify about a registry error
*/
public notifyRegistryError(): void {
this.warn('Failed to retrieve package information.');
this.info('Is the registry down?');
}
/**
* Notify with a complete update check result
*/
public notifyUpdateCheckResult(result: IUpdateCheckResult): void {
switch (result.status) {
case 'up-to-date':
this.notifyUpToDate(result.packageName);
break;
case 'update-available':
if (result.latestVersion) {
this.notifyUpdateAvailable(
result.packageName,
result.currentVersion,
result.latestVersion
);
}
break;
case 'check-skipped':
if (result.nextCheckTime && result.reason) {
const minutesUntilNext = (result.nextCheckTime.getTime() - result.checkTime.getTime()) / 60000;
this.notifyCheckSkipped(result.packageName, minutesUntilNext);
}
break;
case 'error':
if (result.error) {
this.error(result.error.message);
}
break;
}
}
}

View File

@@ -1,107 +1,279 @@
import * as plugins from './smartupdate.plugins';
import { TimeStamp } from '@pushrocks/smarttime';
interface ICacheStatus {
lastCheck: number;
latestVersion: string;
performedUpgrade: boolean;
}
import { KeyValueStore } from '@pushrocks/npmextra';
import * as plugins from './smartupdate.plugins.js';
import { UpdateCacheManager } from './smartupdate.classes.cachemanager.js';
import { UpdateNotifier } from './smartupdate.classes.notifier.js';
import { DEFAULT_CACHE_DURATION_HOURS, MILLISECONDS_PER_MINUTE, MINUTES_PER_HOUR } from './smartupdate.constants.js';
import type {
ISmartUpdateOptions,
IUpdateCheckOptions,
IUpdateCheckResult,
} from './smartupdate.interfaces.js';
import {
RegistryUnavailableError,
PackageNotFoundError,
} from './smartupdate.errors.js';
/**
* SmartUpdate - Elegant update checking for Node.js packages
*
* @example
* ```typescript
* const smartUpdate = new SmartUpdate();
* const result = await smartUpdate.checkForUpdate({
* packageName: 'lodash',
* currentVersion: '1.0.0',
* changelogUrl: 'https://example.com/changelog'
* });
*
* if (result.status === 'update-available') {
* console.log(`Update available: ${result.latestVersion}`);
* }
* ```
*/
export class SmartUpdate {
public npmRegistry: plugins.smartnpm.NpmRegistry;
public kvStore = new plugins.npmextra.KeyValueStore('custom', 'global_smartupdate');
public readonly npmRegistry: plugins.smartnpm.NpmRegistry;
private cacheManager: UpdateCacheManager;
private notifier: UpdateNotifier;
private options: ISmartUpdateOptions;
constructor(optionsArg: plugins.smartnpm.INpmRegistryConstructorOptions = {}) {
this.npmRegistry = new plugins.smartnpm.NpmRegistry(optionsArg);
/**
* @deprecated Use the options parameter instead of kvStore property
*/
public kvStore: plugins.npmextra.KeyValueStore;
constructor(options: ISmartUpdateOptions = {}) {
this.options = options;
// Initialize npm registry
this.npmRegistry = new plugins.smartnpm.NpmRegistry(options.npmRegistryOptions || {});
// Calculate cache duration in milliseconds
const cacheDuration = options.cacheDuration || { hours: DEFAULT_CACHE_DURATION_HOURS };
const cacheDurationMs =
(cacheDuration.hours || 0) * MINUTES_PER_HOUR * MILLISECONDS_PER_MINUTE +
(cacheDuration.minutes || 0) * MILLISECONDS_PER_MINUTE +
(cacheDuration.seconds || 0) * 1000;
// Initialize cache manager
this.cacheManager = new UpdateCacheManager({
durationMs: cacheDurationMs || DEFAULT_CACHE_DURATION_HOURS * MINUTES_PER_HOUR * MILLISECONDS_PER_MINUTE,
});
// Initialize notifier
this.notifier = new UpdateNotifier({
logLevel: options.logLevel || 'INFO',
useColors: !options.noColor,
customLogger: options.customLogger,
});
// Backward compatibility: expose kvStore
this.kvStore = (this.cacheManager as any).kvStore;
}
public async checkForCli(npmnameArg: string, compareVersion: string, changelogUrlArg?: string) {
// the newData to write
const timeStamp = new TimeStamp();
const newCacheData: ICacheStatus = {
lastCheck: timeStamp.milliSeconds,
latestVersion: 'x.x.x',
performedUpgrade: false
/**
* Check for updates with caching (primarily for CLI use)
*
* @deprecated Use checkForUpdate with cacheStrategy: 'always' instead
* @param packageName - The npm package name to check
* @param currentVersion - The current version to compare against
* @param changelogUrl - Optional URL to open if update is available
* @returns Promise resolving to true if update available, false otherwise
*
* @example
* ```typescript
* const hasUpdate = await smartUpdate.checkForCli('my-cli', '1.0.0', 'https://changelog.url');
* ```
*/
public async checkForCli(
packageName: string,
currentVersion: string,
changelogUrl?: string
): Promise<boolean> {
const result = await this.checkForUpdate({
packageName,
currentVersion,
changelogUrl,
cacheStrategy: 'always',
});
return result.status === 'update-available';
}
/**
* Check for updates (modern API)
*
* @param options - Update check options
* @returns Promise resolving to detailed update check result
*
* @example
* ```typescript
* const result = await smartUpdate.checkForUpdate({
* packageName: 'lodash',
* currentVersion: '1.0.0',
* changelogUrl: 'https://changelog.url',
* openChangelog: true,
* cacheStrategy: 'time-based'
* });
*
* console.log(result.status); // 'up-to-date' | 'update-available' | 'check-skipped' | 'error'
* ```
*/
public async checkForUpdate(options: IUpdateCheckOptions): Promise<IUpdateCheckResult> {
const {
packageName,
currentVersion,
changelogUrl,
openChangelog = true,
cacheStrategy = 'time-based',
} = options;
const checkTime = new Date();
try {
// Check if we should use cache or check registry
const cacheCheck = await this.cacheManager.shouldCheckRegistry(packageName, cacheStrategy);
// If we should skip the check due to cache
if (!cacheCheck.shouldCheck) {
return {
status: 'check-skipped',
packageName,
currentVersion,
latestVersion: cacheCheck.cacheStatus?.latestVersion,
checkTime,
cacheHit: true,
nextCheckTime: cacheCheck.nextCheckTime,
reason: 'Rate limited - checked recently',
};
}
// Fetch package info from registry
const npmPackage = await this.getNpmPackageFromRegistry(packageName);
if (!npmPackage) {
throw new RegistryUnavailableError();
}
// Compare versions
const versionNpm = new plugins.smartversion.SmartVersion(npmPackage.version);
const versionLocal = new plugins.smartversion.SmartVersion(currentVersion);
const result: IUpdateCheckResult = {
status: versionNpm.greaterThan(versionLocal) ? 'update-available' : 'up-to-date',
packageName: npmPackage.name,
currentVersion,
latestVersion: npmPackage.version,
checkTime,
cacheHit: false,
};
// the comparison data from the keyValue store
const retrievedCacheData: ICacheStatus = await this.kvStore.readKey(npmnameArg);
// Notify user
this.notifier.notifyUpdateCheckResult(result);
if (retrievedCacheData) {
const lastCheckTimeStamp = TimeStamp.fromMilliSeconds(retrievedCacheData.lastCheck);
const tresholdTime = plugins.smarttime.getMilliSecondsFromUnits({ hours: 1 });
if (!lastCheckTimeStamp.isOlderThan(timeStamp, tresholdTime)) {
newCacheData.lastCheck = lastCheckTimeStamp.milliSeconds;
const nextCheckInMinutes =
(tresholdTime - (timeStamp.milliSeconds - lastCheckTimeStamp.milliSeconds)) / 60000;
console.log(
`next update check in less than ${Math.floor(nextCheckInMinutes) + 1} minute(s): ` +
`${plugins.consolecolor.coloredString(
`${npmnameArg} has already been checked within the last hour.`,
'pink'
)}`
);
return false; // don't upgrade if checked within reasonable time
}
// If update is available, handle changelog
if (result.status === 'update-available' && changelogUrl && openChangelog && !process.env.CI) {
this.notifier.notifyOpeningChangelog();
plugins.smartopen.openUrl(changelogUrl);
}
const upgradeBool = await this.check(npmnameArg, compareVersion, changelogUrlArg);
if (upgradeBool) {
const npmPackage = await this.npmRegistry.getPackageInfo(npmnameArg);
newCacheData.latestVersion = npmPackage.version;
this.kvStore.writeKey(npmnameArg, newCacheData);
// Update cache if there's an update
if (result.status === 'update-available') {
const cacheStatus = this.cacheManager.createCacheStatus(npmPackage.version, false);
await this.cacheManager.setCached(packageName, cacheStatus);
}
return upgradeBool;
}
private async getNpmPackageFromRegistry(npmnameArg): Promise<plugins.smartnpm.NpmPackage> {
console.log(
`smartupdate: checking for newer version of ${plugins.consolecolor.coloredString(
npmnameArg,
'pink'
)}...`
);
const npmPackage = this.npmRegistry.getPackageInfo(npmnameArg);
return npmPackage;
}
public async check(
npmPackageName: string,
localVersionStringArg: string,
changelogUrlArg?: string
) {
const npmPackage = await this.getNpmPackageFromRegistry(npmPackageName);
if (!npmPackage) {
console.log('warn: failed to retrieve package information...');
console.log('info: is the registry down?');
return;
}
// create Version objects
const versionNpm = new plugins.smartversion.SmartVersion(npmPackage.version);
const versionLocal = new plugins.smartversion.SmartVersion(localVersionStringArg);
if (!versionNpm.greaterThan(versionLocal)) {
console.log(
`smartupdate: You are running the latest version of ${plugins.consolecolor.coloredString(
npmPackage.name,
'pink'
)}`
);
return false;
return result;
} catch (error) {
if (error instanceof RegistryUnavailableError) {
this.notifier.notifyRegistryError();
} else {
console.log(`warn: There is a newer version of ${npmPackage.name} available on npm.`);
console.log(
`warn: Your version: ${versionLocal.versionString} | version on npm: ${versionNpm.versionString}`
);
if (!process.env.CI && changelogUrlArg) {
console.log('trying to open changelog...');
plugins.smartopen.openUrl(changelogUrlArg);
this.notifier.error(error instanceof Error ? error.message : String(error));
}
return true;
return {
status: 'error',
packageName,
currentVersion,
checkTime,
cacheHit: false,
error: error instanceof Error ? error : new Error(String(error)),
};
}
}
/**
* Simple check for updates without caching
*
* @deprecated Use checkForUpdate with cacheStrategy: 'never' instead
* @param packageName - The npm package name to check
* @param currentVersion - The current version to compare against
* @param changelogUrl - Optional URL to open if update is available
* @returns Promise resolving to true if update available, false otherwise
*
* @example
* ```typescript
* const hasUpdate = await smartUpdate.check('lodash', '1.0.0');
* ```
*/
public async check(
packageName: string,
currentVersion: string,
changelogUrl?: string
): Promise<boolean> {
const result = await this.checkForUpdate({
packageName,
currentVersion,
changelogUrl,
cacheStrategy: 'never',
});
return result.status === 'update-available';
}
/**
* Get the latest version of a package
*
* @param packageName - The npm package name
* @returns Promise resolving to the latest version string
*
* @example
* ```typescript
* const latestVersion = await smartUpdate.getLatestVersion('lodash');
* console.log(latestVersion); // e.g., "4.17.21"
* ```
*/
public async getLatestVersion(packageName: string): Promise<string> {
const npmPackage = await this.getNpmPackageFromRegistry(packageName);
if (!npmPackage) {
throw new PackageNotFoundError(packageName);
}
return npmPackage.version;
}
/**
* Clear the cache for a specific package
*
* @param packageName - The package name to clear cache for
*
* @example
* ```typescript
* await smartUpdate.clearCache('lodash');
* ```
*/
public async clearCache(packageName: string): Promise<void> {
await this.cacheManager.clearCache(packageName);
}
/**
* Fetch package information from the npm registry
* @private
*/
private async getNpmPackageFromRegistry(packageName: string): Promise<plugins.smartnpm.NpmPackage | null> {
this.notifier.notifyCheckingForUpdate(packageName);
try {
const npmPackage = await this.npmRegistry.getPackageInfo(packageName);
return npmPackage;
} catch (error) {
return null;
}
}
}

View File

@@ -0,0 +1,30 @@
/**
* Constants used throughout the smartupdate library
*/
// Time constants
export const MILLISECONDS_PER_MINUTE = 60_000;
export const MINUTES_PER_HOUR = 60;
export const DEFAULT_CACHE_DURATION_HOURS = 1;
// Console output constants
export const DEFAULT_MESSAGE_COLOR = 'pink';
// Log level constants
export const LOG_LEVELS = {
SILENT: 0,
ERROR: 1,
WARN: 2,
INFO: 3,
DEBUG: 4,
} as const;
export type TLogLevel = keyof typeof LOG_LEVELS;
// Message prefixes
export const MESSAGE_PREFIXES = {
ERROR: 'error:',
WARN: 'warn:',
INFO: 'info:',
SMARTUPDATE: 'smartupdate:',
} as const;

65
ts/smartupdate.errors.ts Normal file
View File

@@ -0,0 +1,65 @@
/**
* Base error class for smartupdate errors
*/
export class SmartUpdateError extends Error {
constructor(message: string) {
super(message);
this.name = 'SmartUpdateError';
// Maintains proper stack trace for where our error was thrown (only available on V8)
if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
}
}
}
/**
* Error thrown when the npm registry is unavailable
*/
export class RegistryUnavailableError extends SmartUpdateError {
constructor(message: string = 'Failed to retrieve package information from npm registry') {
super(message);
this.name = 'RegistryUnavailableError';
}
}
/**
* Error thrown when a package is not found in the registry
*/
export class PackageNotFoundError extends SmartUpdateError {
public readonly packageName: string;
constructor(packageName: string) {
super(`Package '${packageName}' not found in npm registry`);
this.name = 'PackageNotFoundError';
this.packageName = packageName;
}
}
/**
* Error thrown when a version string is invalid
*/
export class InvalidVersionError extends SmartUpdateError {
public readonly version: string;
constructor(version: string, reason?: string) {
const message = reason
? `Invalid version string '${version}': ${reason}`
: `Invalid version string '${version}'`;
super(message);
this.name = 'InvalidVersionError';
this.version = version;
}
}
/**
* Error thrown when package name validation fails
*/
export class InvalidPackageNameError extends SmartUpdateError {
public readonly packageName: string;
constructor(packageName: string) {
super(`Invalid package name '${packageName}'. Package names must follow npm naming conventions.`);
this.name = 'InvalidPackageNameError';
this.packageName = packageName;
}
}

View File

@@ -0,0 +1,171 @@
import type { TLogLevel } from './smartupdate.constants.js';
import type * as smartnpm from '@push.rocks/smartnpm';
/**
* Cache status stored for each package
*/
export interface ICacheStatus {
lastCheck: number;
latestVersion: string;
performedUpgrade: boolean;
}
/**
* Options for configuring the SmartUpdate instance
*/
export interface ISmartUpdateOptions {
/**
* Options for the npm registry connection
*/
npmRegistryOptions?: smartnpm.INpmRegistryConstructorOptions;
/**
* Cache duration configuration
* @default { hours: 1 }
*/
cacheDuration?: {
hours?: number;
minutes?: number;
seconds?: number;
};
/**
* Logging level
* @default 'INFO'
*/
logLevel?: TLogLevel;
/**
* Custom logger function
* If provided, this will be used instead of console output
*/
customLogger?: (level: TLogLevel, message: string) => void;
/**
* Disable colored output
* @default false
*/
noColor?: boolean;
}
/**
* Options for checking for updates
*/
export interface IUpdateCheckOptions {
/**
* The npm package name to check
*/
packageName: string;
/**
* The current version to compare against
*/
currentVersion: string;
/**
* Optional URL to the changelog
* If provided and an update is available, the changelog will be opened
*/
changelogUrl?: string;
/**
* Whether to open the changelog URL automatically
* Only applies if running in a non-CI environment
* @default true
*/
openChangelog?: boolean;
/**
* Cache strategy for this check
* - 'always': Always check cache first (default for CLI)
* - 'never': Always check registry, bypass cache
* - 'time-based': Check based on cache duration
* @default 'time-based'
*/
cacheStrategy?: 'always' | 'never' | 'time-based';
}
/**
* Result of an update check
*/
export interface IUpdateCheckResult {
/**
* Status of the update check
*/
status: 'up-to-date' | 'update-available' | 'check-skipped' | 'error';
/**
* The current version being checked
*/
currentVersion: string;
/**
* The latest version available (if found)
*/
latestVersion?: string;
/**
* The package name that was checked
*/
packageName: string;
/**
* Time when the check was performed
*/
checkTime: Date;
/**
* Whether this result came from cache
*/
cacheHit: boolean;
/**
* When the next check can be performed (if check was skipped due to rate limiting)
*/
nextCheckTime?: Date;
/**
* Error details if status is 'error'
*/
error?: Error;
/**
* Reason for the result (human-readable explanation)
*/
reason?: string;
}
/**
* Options for the cache manager
*/
export interface ICacheOptions {
/**
* Cache duration in milliseconds
*/
durationMs: number;
/**
* Identifier for the key-value store
*/
storeIdentifier?: string;
}
/**
* Options for the notifier
*/
export interface INotificationOptions {
/**
* Log level for notifications
*/
logLevel: TLogLevel;
/**
* Whether to use colors in output
*/
useColors: boolean;
/**
* Custom logger function
*/
customLogger?: (level: TLogLevel, message: string) => void;
}

View File

@@ -1,8 +1,8 @@
import * as consolecolor from '@pushrocks/consolecolor';
import * as npmextra from '@pushrocks/npmextra';
import * as smartnpm from '@pushrocks/smartnpm';
import * as smartopen from '@pushrocks/smartopen';
import * as smarttime from '@pushrocks/smarttime';
import * as smartversion from '@pushrocks/smartversion';
import * as consolecolor from '@push.rocks/consolecolor';
import * as npmextra from '@push.rocks/npmextra';
import * as smartnpm from '@push.rocks/smartnpm';
import * as smartopen from '@push.rocks/smartopen';
import * as smarttime from '@push.rocks/smarttime';
import * as smartversion from '@push.rocks/smartversion';
export { consolecolor, npmextra, smartnpm, smartopen, smarttime, smartversion };

14
tsconfig.json Normal file
View File

@@ -0,0 +1,14 @@
{
"compilerOptions": {
"experimentalDecorators": true,
"useDefineForClassFields": false,
"target": "ES2022",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"verbatimModuleSyntax": true
},
"exclude": [
"dist_*/**/*.d.ts"
]
}

View File

@@ -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"
}