@containerbase/base 14.62.0 → 14.63.1

package/README.md

@@ -112,8 +112,9 @@ A reader can replace its urls the same way, so a mirror configured for container
 ```ts
 import { getUrlReplacements, replaceUrl } from '@containerbase/base';
 
-const { replacements, invalid } = getUrlReplacements(); // reads `process.env`
-// `invalid` lists the `URL_REPLACE_<n>_FROM` variables without a value or `_TO` counterpart
+const { replacements, invalid, withoutScheme } = getUrlReplacements(); // reads `process.env`
+// `invalid` lists the `URL_REPLACE_<n>_FROM` variables without a value or `_TO` counterpart,
+// `withoutScheme` the ones whose value doesn't start with `http://` or `https://`
 replaceUrl(
   'https://containerbase.github.io/tool-versions/v1/node.json',
   replacements,
@@ -121,6 +122,19 @@ replaceUrl(
 );
 ```
 
+`replaceUrl` applies the cdn first, then the replacements like `replaceUrlPrefix(url, rules)`: in order, each to the result of the previous ones, and only when the url starts with its `from`.
+`replaceUrlPrefix` has no cdn step and returns the replaced url with the rules that matched, other fields of the rules are kept.
+End `from` and `to` with a `/`, like `https://example.com/`, so a rule only matches that host: `https://example.com` also matches `https://example.com.test/`.
+
+```ts
+import { replaceUrlPrefix } from '@containerbase/base';
+
+const { url, applied } = replaceUrlPrefix('https://registry.npmjs.org/foo', [
+  { from: 'https://registry.npmjs.org/', to: 'https://npm.example.test/' },
+]);
+// url: 'https://npm.example.test/foo', applied: [the rule]
+```
+
 A tool's data may list `minCb` ranges, the oldest containerbase version which can install a version and every version above it.
 `filterByMinCb(data, cbVersion)` returns the `versions` the given containerbase version can install, in the order of the data, and the `cb` values of the unmet ranges as `needed`.
 A `cbVersion` which isn't a release, like `0.0.0-PLACEHOLDER` (see `isReleaseVersion(version)`), skips the filter:

package/dist/index.d.ts

@@ -8,8 +8,8 @@ export { configure, getLogger, isConfigured } 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';
-export { getUrlReplacements, replaceUrl } from './url.ts';
+export type { UrlPrefixResult, UrlPrefixRule, UrlReplacement, UrlReplacements, } from './url.ts';
+export { getUrlReplacements, replaceUrl, replaceUrlPrefix } from './url.ts';
 export { tools };
 /**
  * The Ubuntu release the default containerbase image is built from, the

package/dist/index.js

@@ -4,7 +4,7 @@ export { configure, getLogger, isConfigured } 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";
+export { getUrlReplacements, replaceUrl, replaceUrlPrefix } from "./url.js";
 export { tools };
 /**
  * The Ubuntu release the default containerbase image is built from, the

package/dist/url.d.ts

@@ -9,6 +9,12 @@ export interface UrlReplacements {
      * their `URL_REPLACE_<n>_TO` counterpart are empty or missing.
      */
     invalid: string[];
+    /**
+     * The `URL_REPLACE_<n>_FROM` variables whose value doesn't start with
+     * `http://` or `https://`, like a bare host. They are used, but only match
+     * urls which start with them.
+     */
+    withoutScheme: string[];
 }
 /**
  * Reads the url replacements from the `URL_REPLACE_<n>_FROM` and
@@ -20,8 +26,9 @@ export declare function getUrlReplacements(env?: Record<string, string | undefin
 /**
  * Replaces a url the way containerbase does for its downloads: with a `cdn`,
  * `https://` is replaced by it first, eg. `https://example.com/file` becomes
- * `<cdn>/example.com/file`. Then every replacement is applied in order, each
- * replacing the first occurrence of its `from` text.
+ * `<cdn>/example.com/file`. Then the replacements are applied in order like
+ * `replaceUrlPrefix`, each to the result of the previous ones and only when
+ * the url starts with its `from`.
  *
  * @param url the url to replace
  * @param replacements the replacements, see `getUrlReplacements`
@@ -29,3 +36,30 @@ export declare function getUrlReplacements(env?: Record<string, string | undefin
  * @returns the replaced url
  */
 export declare function replaceUrl(url: string, replacements: readonly UrlReplacement[], cdn?: string): string;
+/** A url prefix replacement rule, other fields are kept as they are. */
+export interface UrlPrefixRule {
+    /** The url prefix to replace. */
+    from: string;
+    /** Its replacement. */
+    to: string;
+}
+/** The result of `replaceUrlPrefix`. */
+export interface UrlPrefixResult<T extends UrlPrefixRule> {
+    /** The replaced url. */
+    url: string;
+    /** The rules which matched, in order. */
+    applied: T[];
+}
+/**
+ * Replaces url prefixes: the rules are applied in order, each one to the
+ * result of the previous ones, and a rule only applies when the url starts
+ * with its `from`, which is then replaced by its `to`. A `from` elsewhere in
+ * the url never matches, and unlike `replaceUrl` there is no cdn. End `from`
+ * and `to` with a `/`, like `https://example.com/`, so a rule only matches that
+ * host: `https://example.com` also matches `https://example.com.test/`.
+ *
+ * @param url the url to replace
+ * @param rules the rules, in order
+ * @returns the replaced url and the rules which matched
+ */
+export declare function replaceUrlPrefix<T extends UrlPrefixRule>(url: string, rules: readonly T[]): UrlPrefixResult<T>;

package/dist/url.js

@@ -1,4 +1,5 @@
 const fromRe = /^URL_REPLACE_\d+_FROM$/;
+const schemeRe = /^https?:\/\//;
 const collator = new Intl.Collator('en', {
     sensitivity: 'base',
     numeric: true,
@@ -10,7 +11,11 @@ const collator = new Intl.Collator('en', {
  * @param env the environment to read, `process.env` by default
  */
 export function getUrlReplacements(env = process.env) {
-    const result = { replacements: [], invalid: [] };
+    const result = {
+        replacements: [],
+        invalid: [],
+        withoutScheme: [],
+    };
     for (const from of Object.keys(env)
         .filter((key) => fromRe.test(key))
         .sort((a, b) => collator.compare(a, b))) {
@@ -19,6 +24,9 @@ export function getUrlReplacements(env = process.env) {
         const toValue = env[to];
         if (fromValue && toValue) {
             result.replacements.push([fromValue, toValue]);
+            if (!schemeRe.test(fromValue)) {
+                result.withoutScheme.push(from);
+            }
         }
         else {
             result.invalid.push(from);
@@ -29,8 +37,9 @@ export function getUrlReplacements(env = process.env) {
 /**
  * Replaces a url the way containerbase does for its downloads: with a `cdn`,
  * `https://` is replaced by it first, eg. `https://example.com/file` becomes
- * `<cdn>/example.com/file`. Then every replacement is applied in order, each
- * replacing the first occurrence of its `from` text.
+ * `<cdn>/example.com/file`. Then the replacements are applied in order like
+ * `replaceUrlPrefix`, each to the result of the previous ones and only when
+ * the url starts with its `from`.
  *
  * @param url the url to replace
  * @param replacements the replacements, see `getUrlReplacements`
@@ -42,8 +51,28 @@ export function replaceUrl(url, replacements, cdn) {
     if (cdn) {
         result = result.replace(/^https:\//, cdn.replace(/\/$/, ''));
     }
-    for (const [from, to] of replacements) {
-        result = result.replace(from, to);
+    return replaceUrlPrefix(result, replacements.map(([from, to]) => ({ from, to }))).url;
+}
+/**
+ * Replaces url prefixes: the rules are applied in order, each one to the
+ * result of the previous ones, and a rule only applies when the url starts
+ * with its `from`, which is then replaced by its `to`. A `from` elsewhere in
+ * the url never matches, and unlike `replaceUrl` there is no cdn. End `from`
+ * and `to` with a `/`, like `https://example.com/`, so a rule only matches that
+ * host: `https://example.com` also matches `https://example.com.test/`.
+ *
+ * @param url the url to replace
+ * @param rules the rules, in order
+ * @returns the replaced url and the rules which matched
+ */
+export function replaceUrlPrefix(url, rules) {
+    let result = url;
+    const applied = [];
+    for (const rule of rules) {
+        if (result.startsWith(rule.from)) {
+            result = rule.to + result.slice(rule.from.length);
+            applied.push(rule);
+        }
     }
-    return result;
+    return { url: result, applied };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@containerbase/base",
-  "version": "14.62.0",
+  "version": "14.63.1",
   "description": "Metadata about the tools supported by containerbase",
   "keywords": [
     "containerbase",