@containerbase/base 14.56.0 → 14.57.1

package/README.md

@@ -48,7 +48,7 @@ defaultDistro; // 'noble'
 ```
 
 The format of the published [tool-versions](https://github.com/containerbase/tool-versions/blob/main/docs/format.md) data is exported too, so its readers share one definition.
-The zod schemas (`ToolVersions`, `VersionFiles`, `VersionIntegrity`, `ToolIndex`, `FormatIndex` and their parts) live behind the `zod` entry point, the zod free types behind the main one:
+The zod schemas (`ToolVersions`, `VersionFiles`, `VersionIntegrity`, `ToolIndex`, `FormatIndex`, `ReleaseInfo` and their parts) live behind the `zod` entry point, the zod free types behind the main one:
 
 ```ts
 import { ToolVersions } from '@containerbase/base/zod';
@@ -134,8 +134,28 @@ declare const data: ToolVersions; // the content of eg. `node.json`
 const { versions, needed } = filterByMinCb(data, packageVersion);
 ```
 
+`minCbByVersion(data)` returns the containerbase version each covered tool version needs as a `Map` by version, the newest `cb` of the ranges covering it.
+A `cb` which isn't valid semver wins over valid ones, as it is never met.
+Versions no range covers aren't listed:
+
+```ts
+import { minCbByVersion } from '@containerbase/base';
+
+const needs = minCbByVersion(data); // eg. `needs.get('2.0.0')` is `'14.51.0'`
+```
+
 The schemas ignore unknown keys and accept any arch name, so additive changes of the format don't break a reader; readers ignore files of an arch they don't know.
 
+The package logs nothing by default.
+`configure({ logger })` sets the logger its functions log to, eg. a pino or Renovate logger, and `configure()` turns logging off again:
+
+```ts
+import { configure } from '@containerbase/base';
+import { logger } from './logger.ts';
+
+configure({ logger });
+```
+
 ## Contents
 
 Each entry may carry the following metadata:

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 import { tools } from './data.ts';
 import type { DistroCode } from './types.ts';
 export type { Arch, DistroCode, InstallToolType, ToolMetadata, ToolType, } from './types.ts';
-export type { FileIntegrity, FileReference, FormatIndex, ToolFile, ToolIndex, ToolVersion, ToolVersions, VersionFiles, VersionIntegrity, } from './tool-versions-types.ts';
+export type { FileIntegrity, FileReference, FormatIndex, ReleaseInfo, ToolFile, ToolIndex, ToolVersion, ToolVersions, VersionFiles, VersionIntegrity, } from './tool-versions-types.ts';
 export { containerbaseVersionFile, isCompatibleVersion, isContainerbase, packageVersion, toolVersionsPath, validateContainerbaseVersion, } from './containerbase.ts';
-export { filterByMinCb } from './min-cb.ts';
+export type { ConfigureOptions, LogFn, Logger } from './logger.ts';
+export { configure } from './logger.ts';
+export { filterByMinCb, minCbByVersion } from './min-cb.ts';
 export { isReleaseVersion } from './release-version.ts';
 export { isToolVersionsFormat, toolVersionsFormat, toolVersionsFormatPath, } from './tool-versions-format.ts';
 export type { UrlReplacement, UrlReplacements } from './url.ts';

package/dist/index.js

@@ -1,6 +1,7 @@
 import { tools } from "./data.js";
 export { containerbaseVersionFile, isCompatibleVersion, isContainerbase, packageVersion, toolVersionsPath, validateContainerbaseVersion, } from "./containerbase.js";
-export { filterByMinCb } from "./min-cb.js";
+export { configure } from "./logger.js";
+export { filterByMinCb, minCbByVersion } from "./min-cb.js";
 export { isReleaseVersion } from "./release-version.js";
 export { isToolVersionsFormat, toolVersionsFormat, toolVersionsFormatPath, } from "./tool-versions-format.js";
 export { getUrlReplacements, replaceUrl } from "./url.js";

package/dist/logger.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A log method, called with a message or with metadata and an optional
+ * message, like the methods of a pino or Renovate logger.
+ */
+export interface LogFn {
+    (msg: string): void;
+    (meta: Record<string, unknown>, msg?: string): void;
+}
+/** The logger the package functions log to, see `configure`. */
+export interface Logger {
+    trace: LogFn;
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+}
+/** The package options `configure` sets. */
+export interface ConfigureOptions {
+    /** The logger to log to, nothing is logged without one. */
+    logger?: Logger;
+}
+/**
+ * Configures the package, eg. sets the logger its functions log to. Options
+ * which are left out are reset to their defaults.
+ *
+ * @param options the options to set
+ */
+export declare function configure(options?: ConfigureOptions): void;
+/** The logger set by `configure`, a silent one by default. */
+export declare function getLogger(): Logger;

package/dist/logger.js

@@ -0,0 +1,24 @@
+const noop = () => {
+    // logging is off
+};
+const silentLogger = {
+    trace: noop,
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+};
+let current = silentLogger;
+/**
+ * Configures the package, eg. sets the logger its functions log to. Options
+ * which are left out are reset to their defaults.
+ *
+ * @param options the options to set
+ */
+export function configure(options = {}) {
+    current = options.logger ?? silentLogger;
+}
+/** The logger set by `configure`, a silent one by default. */
+export function getLogger() {
+    return current;
+}

package/dist/min-cb.d.ts

@@ -18,3 +18,17 @@ export declare function filterByMinCb(data: ToolVersions, cbVersion: string): {
     versions: ToolVersion[];
     needed: string[];
 };
+/**
+ * Lists the containerbase version each tool version needs, by the `minCb`
+ * ranges of its data.
+ *
+ * The data lists the newest release first. A range covers its `version` and
+ * every version above it in the data, prereleases count for the position. A
+ * range whose `version` is not listed is ignored. A version covered by several
+ * ranges needs the newest `cb`, a `cb` which is not valid semver is never met
+ * and so wins over the valid ones, the first of several invalid ones is kept.
+ * @param data - the tool-versions data of a tool
+ * @returns the needed `cb` by version, versions without a covering range are
+ * not listed
+ */
+export declare function minCbByVersion(data: ToolVersions): Map<string, string>;

package/dist/min-cb.js

@@ -1,3 +1,4 @@
+import semverGt from 'semver/functions/gt.js';
 import semverGte from 'semver/functions/gte.js';
 import semverValid from 'semver/functions/valid.js';
 import { isReleaseVersion } from "./release-version.js";
@@ -33,3 +34,32 @@ export function filterByMinCb(data, cbVersion) {
     }
     return { versions: data.versions.slice(unmet + 1), needed };
 }
+/**
+ * Lists the containerbase version each tool version needs, by the `minCb`
+ * ranges of its data.
+ *
+ * The data lists the newest release first. A range covers its `version` and
+ * every version above it in the data, prereleases count for the position. A
+ * range whose `version` is not listed is ignored. A version covered by several
+ * ranges needs the newest `cb`, a `cb` which is not valid semver is never met
+ * and so wins over the valid ones, the first of several invalid ones is kept.
+ * @param data - the tool-versions data of a tool
+ * @returns the needed `cb` by version, versions without a covering range are
+ * not listed
+ */
+export function minCbByVersion(data) {
+    const result = new Map();
+    for (const range of data.minCb ?? []) {
+        const start = data.versions.findIndex((v) => v.version === range.version);
+        for (let i = 0; i <= start; i++) {
+            const version = data.versions[i].version;
+            const current = result.get(version);
+            if (current === undefined ||
+                (semverValid(current) !== null &&
+                    (semverValid(range.cb) === null || semverGt(range.cb, current)))) {
+                result.set(version, range.cb);
+            }
+        }
+    }
+    return result;
+}

package/dist/tool-versions-schema.d.ts

@@ -20,6 +20,7 @@ export declare const ToolVersion: z.ZodObject<{
     version: z.ZodString;
     prerelease: z.ZodExactOptional<z.ZodLiteral<true>>;
     lts: z.ZodExactOptional<z.ZodLiteral<true>>;
+    deprecated: z.ZodExactOptional<z.ZodLiteral<true>>;
     releaseTimestamp: z.ZodExactOptional<z.ZodISODateTime>;
     files: z.ZodExactOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -44,6 +45,8 @@ export declare const ToolVersions: z.ZodObject<{
     }>>;
     sourceUrl: z.ZodExactOptional<z.ZodURL>;
     homepage: z.ZodExactOptional<z.ZodURL>;
+    lts: z.ZodExactOptional<z.ZodLiteral<true>>;
+    latest: z.ZodExactOptional<z.ZodString>;
     minVersion: z.ZodExactOptional<z.ZodString>;
     distroMinVersion: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     minCb: z.ZodExactOptional<z.ZodArray<z.ZodObject<{
@@ -55,6 +58,7 @@ export declare const ToolVersions: z.ZodObject<{
         version: z.ZodString;
         prerelease: z.ZodExactOptional<z.ZodLiteral<true>>;
         lts: z.ZodExactOptional<z.ZodLiteral<true>>;
+        deprecated: z.ZodExactOptional<z.ZodLiteral<true>>;
         releaseTimestamp: z.ZodExactOptional<z.ZodISODateTime>;
         files: z.ZodExactOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -131,3 +135,13 @@ export declare const FormatIndex: z.ZodObject<{
         removalDate: z.ZodExactOptional<z.ZodISODate>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * The content of the root `release.json` file: the release the data belongs to
+ * and when it was built, so a reader with embedded data can tell whether the
+ * online data is newer without fetching it.
+ */
+export declare const ReleaseInfo: z.ZodObject<{
+    $schema: z.ZodExactOptional<z.ZodURL>;
+    version: z.ZodString;
+    buildTime: z.ZodISODateTime;
+}, z.core.$strip>;

package/dist/tool-versions-schema.js

@@ -45,6 +45,8 @@ export const ToolVersion = z.object({
     version: z.string().min(1),
     prerelease: z.literal(true).exactOptional(),
     lts: z.literal(true).exactOptional(),
+    /** the registry deprecates the version, only for npm tools */
+    deprecated: z.literal(true).exactOptional(),
     /** when the version was released, in UTC */
     releaseTimestamp: z.iso.datetime().exactOptional(),
     /**
@@ -85,6 +87,13 @@ export const ToolVersions = z.object({
     sourceUrl: z.url({ protocol: /^https$/ }).exactOptional(),
     /** the homepage of the tool, omitted when unset */
     homepage: z.url({ protocol: /^https$/ }).exactOptional(),
+    /** the tool has LTS release streams, like `node` and `java` */
+    lts: z.literal(true).exactOptional(),
+    /**
+     * the version of the npm `latest` dist-tag, only for npm tools and only when
+     * it is listed in `versions`
+     */
+    latest: z.string().min(1).exactOptional(),
     /**
      * the oldest version containerbase supports, on the `defaultDistro` of the
      * root index, in the versioning of the tool. Older versions aren't listed.
@@ -179,3 +188,15 @@ export const FormatIndex = z.object({
         removalDate: z.iso.date().exactOptional(),
     })),
 });
+/**
+ * The content of the root `release.json` file: the release the data belongs to
+ * and when it was built, so a reader with embedded data can tell whether the
+ * online data is newer without fetching it.
+ */
+export const ReleaseInfo = z.object({
+    $schema: SchemaUrl,
+    /** the version of the release, like `1.7.22` */
+    version: z.string().min(1),
+    /** when the build of the data started, in UTC */
+    buildTime: z.iso.datetime(),
+});

package/dist/tool-versions-types.d.ts

@@ -41,6 +41,10 @@ export interface ToolVersion {
     version: string;
     prerelease?: true;
     lts?: true;
+    /**
+     * The registry deprecates the version, only for npm tools.
+     */
+    deprecated?: true;
     /**
      * When the version was released, in UTC.
      */
@@ -88,6 +92,15 @@ export interface ToolVersions {
      * The homepage of the tool, omitted when unset.
      */
     homepage?: string;
+    /**
+     * The tool has LTS release streams, like `node` and `java`.
+     */
+    lts?: true;
+    /**
+     * The version of the npm `latest` dist-tag, only for npm tools and only when
+     * it is listed in `versions`.
+     */
+    latest?: string;
     /**
      * The oldest version containerbase supports, on the `defaultDistro` of the
      * root index, in the versioning of the tool. Older versions aren't listed.
@@ -214,3 +227,22 @@ export interface FormatIndex {
         removalDate?: string;
     }[];
 }
+/**
+ * The content of the root `release.json` file: the release the data belongs to
+ * and when it was built, so a reader with embedded data can tell whether the
+ * online data is newer without fetching it.
+ */
+export interface ReleaseInfo {
+    /**
+     * The url of the json schema of the file, which identifies its format.
+     */
+    $schema?: string;
+    /**
+     * The version of the release, like `1.7.22`.
+     */
+    version: string;
+    /**
+     * When the build of the data started, in UTC.
+     */
+    buildTime: string;
+}

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "@containerbase/base",
-  "version": "14.56.0",
+  "version": "14.57.1",
   "description": "Metadata about the tools supported by containerbase",
   "keywords": [
     "containerbase",
     "tools"
   ],
   "homepage": "https://github.com/containerbase/base#readme",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/containerbase/base.git",
     "directory": "packages/base"
   },
-  "license": "MIT",
+  "files": [
+    "data",
+    "dist"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -27,10 +31,10 @@
     "./tools.json": "./data/tools.json",
     "./tools.schema.json": "./data/tools.schema.json"
   },
-  "files": [
-    "data",
-    "dist"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "dependencies": {
     "semver": "^7.8.5"
   },
@@ -48,9 +52,5 @@
   },
   "engines": {
     "node": ">=24.10.0"
-  },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
   }
 }