@lakutata/docker 3.0.0-beta.0

package/dist/cjs/docker/lib/DockerImage.js

@@ -0,0 +1,273 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerImage = void 0;
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const DockerStreams_js_1 = require("../../client/DockerStreams.js");
+const Time_1 = require("@lakutata/utils/Time");
+const ImageTagOptions_js_1 = require("../options/image/ImageTagOptions.js");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const ImageExportOptions_js_1 = require("../options/image/ImageExportOptions.js");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("stream/promises");
+const DockerImageRepoTagNotFoundException_js_1 = require("../exceptions/DockerImageRepoTagNotFoundException.js");
+const ImageRemoveOptions_js_1 = require("../options/image/ImageRemoveOptions.js");
+const ImagePushOptions_js_1 = require("../options/image/ImagePushOptions.js");
+const DockerImagePushException_js_1 = require("../exceptions/DockerImagePushException.js");
+const utils_1 = require("@lakutata/utils");
+const ParseRepositoryTag_js_1 = require("./ParseRepositoryTag.js");
+const ParseEnvToRecord_js_1 = require("./ParseEnvToRecord.js");
+const ContainerSettingOptions_js_1 = require("../options/container/ContainerSettingOptions.js");
+const RegistryAuth_js_1 = require("./RegistryAuth.js");
+/**
+ * An image of the Docker daemon, with its tags, platform, size and configuration as inspected, and its operations: tag,
+ * export, push, remove, and run a container. It is not created with `new`: {@link Docker.getImage},
+ * {@link Docker.listImages}, {@link Docker.pullImage}, {@link Docker.buildImage}, {@link Docker.importImage} and
+ * {@link DockerContainer.commit} return it.
+ *
+ * Its properties are a snapshot, taken when it is obtained and refreshed by `tag()` and `push()`. Its operations reject
+ * with {@link DockerImageNotFoundException} when the image was removed, with {@link DockerRequestException} when the
+ * daemon refuses them otherwise (used by a container: HTTP 409), and with the network error of Node.js when the daemon
+ * cannot be reached.
+ * @example
+ * ```typescript
+ * import {type Docker, type DockerContainer, type DockerImage} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * const image: DockerImage = await docker.buildImage({workdir: '/srv/app', files: ['Dockerfile', 'src', 'package.json'], repoTag: 'app:1.0.0'})
+ * console.log(image.id, image.platform, image.size, image.config.ports)
+ * await image.tag({repo: 'registry.example.com/team/app', tag: '1.0.0'})
+ * await image.push({
+ *     repo: 'registry.example.com/team/app',
+ *     tag: '1.0.0',
+ *     auth: {serverAddress: 'registry.example.com', username: 'ci', password: 'secret'}
+ * })
+ * await image.export({destination: '/tmp/app-1.0.0.tar', repoTag: 'app:1.0.0'})
+ * const container: DockerContainer = await image.run({name: 'app', ports: [{port: 3000, type: 'tcp', hostPorts: [3000]}]})
+ * console.log(container.state.status)
+ * ```
+ */
+let DockerImage = class DockerImage extends core_1.Provider {
+    #abortController = new AbortController();
+    /**
+     * Inspect the image.
+     * @throws {DockerImageNotFoundException} When the image does not exist.
+     * @protected
+     */
+    async init() {
+        await this.syncImageInfo();
+    }
+    /**
+     * Abort the export in progress of the object (the image itself is left as it is).
+     * @protected
+     */
+    async destroy() {
+        this.#abortController.abort();
+    }
+    /**
+     * Refresh the properties from the daemon's inspection of the image.
+     * @throws {DockerImageNotFoundException} When the image does not exist.
+     * @protected
+     */
+    async syncImageInfo() {
+        const inspectInfo = await this.getClient().inspectImage(this.id);
+        this.repoTags = inspectInfo.RepoTags;
+        this.createdAt = new Time_1.Time(inspectInfo.Created);
+        this.arch = inspectInfo.Architecture;
+        this.os = inspectInfo.Os;
+        this.platform = `${this.os}/${this.arch}`;
+        this.size = inspectInfo.Size;
+        const exposePorts = [];
+        const exposePortMap = new Map();
+        if (inspectInfo.Config.ExposedPorts) {
+            Object.keys(inspectInfo.Config.ExposedPorts).forEach((portWithType) => {
+                const portInfos = portWithType.split('/');
+                const port = parseInt(portInfos[0]);
+                const type = (0, utils_1.As)(portInfos[1].toLowerCase());
+                if (!exposePortMap.has(port))
+                    exposePortMap.set(port, { tcp: false, udp: false });
+                const portType = exposePortMap.get(port);
+                portType[type] = true;
+                exposePortMap.set(port, portType);
+            });
+            exposePortMap.forEach((portType, port) => exposePorts.push({ port: port, ...portType }));
+        }
+        this.config = {
+            hostname: inspectInfo.Config.Hostname,
+            user: inspectInfo.Config.User,
+            env: (0, ParseEnvToRecord_js_1.parseEnvToRecord)(inspectInfo.Config.Env),
+            cmd: inspectInfo.Config.Cmd,
+            entrypoint: inspectInfo.Config.Entrypoint
+                ? Array.isArray(inspectInfo.Config.Entrypoint)
+                    ? inspectInfo.Config.Entrypoint
+                    : [inspectInfo.Config.Entrypoint]
+                : [],
+            volumes: inspectInfo.Config.Volumes ? Object.keys(inspectInfo.Config.Volumes) : [],
+            ports: exposePorts
+        };
+    }
+    /**
+     * Add a tag to the image, as `docker tag`, then refresh its properties. A tag already given to another image moves to
+     * this one.
+     * @param options The repository (`registry.example.com/team/app`) and the tag (`latest` by default).
+     * @throws {DockerImageNotFoundException} When the image was removed.
+     * @throws {DockerRequestException} When the name is invalid (HTTP 400).
+     */
+    async tag(options) {
+        try {
+            await this.getClient().tagImage(this.id, { repo: options.repo, tag: options.tag });
+            await this.syncImageInfo();
+        }
+        catch (e) {
+            if (!(0, utils_1.isAbortError)(e))
+                throw e;
+        }
+    }
+    /**
+     * Save the image as a tar archive, as `docker save`, which {@link Docker.importImage} loads. With `repoTag`, the
+     * archive holds that tag (restored when it is loaded); without it, the image is saved by ID, without its tags.
+     * @param options The `destination` (a file path, created or overwritten, or a writable stream, ended after the
+     * archive), the tag saved (`repoTag`), and `createRepoTagIfNotExists` (`true` by default) to add that tag to the image
+     * when it does not have it.
+     * @throws {DockerImageRepoTagNotFoundException} When the image does not have `repoTag` and
+     * `createRepoTagIfNotExists` is `false`.
+     * @throws {DockerImageNotFoundException} When the image was removed.
+     * @throws {Error} The error of the destination.
+     */
+    async export(options) {
+        try {
+            let name = this.id;
+            if (options.repoTag) {
+                if (!this.repoTags.includes(options.repoTag)) {
+                    if (!options.createRepoTagIfNotExists)
+                        throw new DockerImageRepoTagNotFoundException_js_1.DockerImageRepoTagNotFoundException('The current image does not contain the RepoTag of {0}', [options.repoTag]);
+                    const { repo, tag } = (0, ParseRepositoryTag_js_1.parseRepositoryTag)(options.repoTag);
+                    await this.tag({ repo: repo, tag: tag });
+                }
+                name = options.repoTag;
+            }
+            const readableStream = await this.getClient().exportImage(name);
+            const destStream = typeof options.destination === 'string'
+                ? (0, node_fs_1.createWriteStream)(options.destination, { signal: this.#abortController.signal })
+                : options.destination;
+            await (0, promises_1.pipeline)(readableStream, destStream);
+        }
+        catch (e) {
+            if (!(0, utils_1.isAbortError)(e))
+                throw e;
+        }
+    }
+    /**
+     * Push the image to its registry, as `docker push`, and wait for its end. The image is first tagged `repo:tag` (the
+     * tag is kept afterwards).
+     * @param options The repository, with its registry (`registry.example.com/team/app`); the tag (`latest` by default);
+     * the registry credentials; and a callback receiving each progress message.
+     * @throws {DockerImagePushException} When the registry refuses the push (refused credentials, a repository not
+     * found).
+     * @throws {DockerImageNotFoundException} When the image was removed.
+     * @throws {DockerRequestException} When the daemon refuses to push it.
+     */
+    async push(options) {
+        const tag = options.tag ? options.tag : 'latest';
+        await this.tag({ repo: options.repo, tag: tag });
+        await this.syncImageInfo();
+        let pushException;
+        const readableStream = await this.getClient().pushImage(options.repo, { tag: tag }, (0, RegistryAuth_js_1.registryAuth)(options.auth));
+        await (0, DockerStreams_js_1.followProgress)(readableStream, (outputObject) => {
+            if (outputObject.error && !pushException)
+                pushException = new DockerImagePushException_js_1.DockerImagePushException(outputObject.error);
+            if (options.outputCallback)
+                options.outputCallback(outputObject);
+        });
+        if (pushException)
+            throw pushException;
+    }
+    /**
+     * Remove the image, as `docker rmi -f` by default: forced, it is removed with all its tags, even when a stopped
+     * container uses it.
+     * @param options `force` (`true` by default; `false` refuses an image with several tags or used by a container) and
+     * `noprune` (keeps its untagged parent images; `false` by default).
+     * @throws {DockerImageNotFoundException} When the image was already removed.
+     * @throws {DockerRequestException} When it is used by a running container or, without `force`, by any container or
+     * with several tags (HTTP 409).
+     */
+    async remove(options) {
+        try {
+            await this.getClient().removeImage(this.id, { force: options?.force, noprune: options?.noprune });
+        }
+        catch (e) {
+            if (!(0, utils_1.isAbortError)(e))
+                throw e;
+        }
+    }
+    /**
+     * Create a container from the image, for its platform, then start it, as `docker run -d`.
+     * @param options The container's settings: name, command, environment, ports, binds, devices, networks, limits…
+     * @returns The container, started.
+     * @throws {DockerRequestException} When the name is already used (HTTP 409), or the start fails (HTTP 500: a command
+     * not found, a port already used); the container then stays created.
+     * @throws {DockerNetworkNotFoundException} When a network of the settings is not found.
+     * @throws {InvalidMethodAcceptException} When the settings are invalid.
+     */
+    async run(options) {
+        const container = await this.getDocker().createContainer(this.id, this.platform, options);
+        await container.start();
+        return container;
+    }
+};
+exports.DockerImage = DockerImage;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function()),
+    __metadata("design:type", Function)
+], DockerImage.prototype, "getClient", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Function()),
+    __metadata("design:type", Function)
+], DockerImage.prototype, "getDocker", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String()),
+    __metadata("design:type", String)
+], DockerImage.prototype, "id", void 0);
+__decorate([
+    (0, dto_1.Accept)(ImageTagOptions_js_1.ImageTagOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageTagOptions_js_1.ImageTagOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "tag", null);
+__decorate([
+    (0, dto_1.Accept)(ImageExportOptions_js_1.ImageExportOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageExportOptions_js_1.ImageExportOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "export", null);
+__decorate([
+    (0, dto_1.Accept)(ImagePushOptions_js_1.ImagePushOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImagePushOptions_js_1.ImagePushOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "push", null);
+__decorate([
+    (0, dto_1.Accept)(ImageRemoveOptions_js_1.ImageRemoveOptions.optional().default({ force: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ImageRemoveOptions_js_1.ImageRemoveOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "remove", null);
+__decorate([
+    (0, dto_1.Accept)(ContainerSettingOptions_js_1.ContainerSettingOptions.required()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ContainerSettingOptions_js_1.ContainerSettingOptions]),
+    __metadata("design:returntype", Promise)
+], DockerImage.prototype, "run", null);
+exports.DockerImage = DockerImage = __decorate([
+    (0, di_1.Transient)()
+], DockerImage);

package/dist/cjs/docker/lib/EngineSettings.d.ts

@@ -0,0 +1,41 @@
+import { type ContainerSettingOptions } from '../options/container/ContainerSettingOptions.js';
+import { type ContainerRestartPolicy } from '../types/ContainerRestartPolicy.js';
+import { type DeviceMapping } from '../../client/types/DeviceMapping.js';
+import { type PortBinding } from '../../client/types/PortBinding.js';
+/**
+ * The restart policy of the Engine API: "on-failure:3" is the policy on-failure with 3 retries at most
+ * @param restartPolicy
+ */
+export declare function engineRestartPolicy(restartPolicy: ContainerRestartPolicy): {
+    Name: string;
+    MaximumRetryCount?: number;
+};
+/**
+ * The restart policy of a container, from the one of the Engine API
+ * @param restartPolicy
+ */
+export declare function parseRestartPolicy(restartPolicy?: {
+    Name?: string;
+    MaximumRetryCount?: number;
+} | null): ContainerRestartPolicy;
+/**
+ * The port bindings of the Engine API ("80/tcp": [{HostPort: "8080"}]): each host port once, null for a port published
+ * on no host port
+ * @param ports
+ */
+export declare function enginePortBindings(ports: NonNullable<ContainerSettingOptions['ports']>): Record<string, PortBinding[] | null>;
+/**
+ * The bind mounts of the Engine API ("hostPath:containerPath:rw")
+ * @param binds
+ */
+export declare function engineBinds(binds: NonNullable<ContainerSettingOptions['binds']>): string[];
+/**
+ * The devices of the Engine API
+ * @param devices
+ */
+export declare function engineDevices(devices: NonNullable<ContainerSettingOptions['devices']>): DeviceMapping[];
+/**
+ * The endpoints of the Engine API, by network: the static addresses given, none on the reserved networks
+ * @param networks
+ */
+export declare function engineEndpoints(networks: NonNullable<ContainerSettingOptions['networks']>): Record<string, Record<string, unknown>>;

package/dist/cjs/docker/lib/EngineSettings.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.engineRestartPolicy = engineRestartPolicy;
+exports.parseRestartPolicy = parseRestartPolicy;
+exports.enginePortBindings = enginePortBindings;
+exports.engineBinds = engineBinds;
+exports.engineDevices = engineDevices;
+exports.engineEndpoints = engineEndpoints;
+/**
+ * The networks Docker creates itself: the addresses of their endpoints cannot be set
+ */
+const RESERVED_NETWORKS = ['bridge', 'host', 'none'];
+/**
+ * The restart policy of the Engine API: "on-failure:3" is the policy on-failure with 3 retries at most
+ * @param restartPolicy
+ */
+function engineRestartPolicy(restartPolicy) {
+    const [name, retries] = restartPolicy.split(':');
+    return retries === undefined ? { Name: name } : { Name: name, MaximumRetryCount: Number.parseInt(retries, 10) };
+}
+/**
+ * The restart policy of a container, from the one of the Engine API
+ * @param restartPolicy
+ */
+function parseRestartPolicy(restartPolicy) {
+    if (!restartPolicy?.Name)
+        return '';
+    if (restartPolicy.Name === 'on-failure' && restartPolicy.MaximumRetryCount)
+        return `on-failure:${restartPolicy.MaximumRetryCount}`;
+    return restartPolicy.Name;
+}
+/**
+ * The port bindings of the Engine API ("80/tcp": [{HostPort: "8080"}]): each host port once, null for a port published
+ * on no host port
+ * @param ports
+ */
+function enginePortBindings(ports) {
+    const hostPortsMap = new Map();
+    for (const port of ports) {
+        const key = `${port.port}/${port.type}`;
+        const hostPorts = hostPortsMap.get(key) ?? new Set();
+        port.hostPorts?.forEach((hostPort) => hostPorts.add(hostPort));
+        hostPortsMap.set(key, hostPorts);
+    }
+    const portBindings = {};
+    hostPortsMap.forEach((hostPorts, key) => {
+        portBindings[key] = hostPorts.size ? [...hostPorts].map((hostPort) => ({ HostPort: hostPort.toString() })) : null;
+    });
+    return portBindings;
+}
+/**
+ * The bind mounts of the Engine API ("hostPath:containerPath:rw")
+ * @param binds
+ */
+function engineBinds(binds) {
+    return binds.map((bind) => `${bind.hostPath}:${bind.containerPath}:${bind.rw ? 'rw' : 'ro'}`);
+}
+/**
+ * The devices of the Engine API
+ * @param devices
+ */
+function engineDevices(devices) {
+    return devices.map((device) => ({
+        PathOnHost: device.hostPath,
+        PathInContainer: device.containerPath,
+        CgroupPermissions: device.cgroupPermissions
+    }));
+}
+/**
+ * The endpoints of the Engine API, by network: the static addresses given, none on the reserved networks
+ * @param networks
+ */
+function engineEndpoints(networks) {
+    const endpoints = {};
+    for (const network of networks) {
+        endpoints[network.networkName] = RESERVED_NETWORKS.includes(network.networkName)
+            ? {}
+            : {
+                IPAMConfig: {
+                    IPv4Address: network.ip ? network.ip : undefined,
+                    IPv6Address: network.ipv6 ? network.ipv6 : undefined
+                }
+            };
+    }
+    return endpoints;
+}

package/dist/cjs/docker/lib/ParseBaseImages.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The images of the FROM instructions of a Dockerfile, pulled before a build with credentials: their flags (--platform)
+ * and their stage names (AS build) are skipped, the stages of the Dockerfile and scratch are not images, the variables
+ * are the ARG declared before the first FROM (with their defaults) and the build arguments. The images whose variables
+ * are unknown are skipped
+ * @param dockerfile the content of the Dockerfile
+ * @param buildargs
+ */
+export declare function parseBaseImages(dockerfile: string, buildargs?: Record<string, string>): string[];

package/dist/cjs/docker/lib/ParseBaseImages.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBaseImages = parseBaseImages;
+/**
+ * The images of the FROM instructions of a Dockerfile, pulled before a build with credentials: their flags (--platform)
+ * and their stage names (AS build) are skipped, the stages of the Dockerfile and scratch are not images, the variables
+ * are the ARG declared before the first FROM (with their defaults) and the build arguments. The images whose variables
+ * are unknown are skipped
+ * @param dockerfile the content of the Dockerfile
+ * @param buildargs
+ */
+function parseBaseImages(dockerfile, buildargs = {}) {
+    //The instructions continued on the next lines (a backslash at the end of a line)
+    const instructions = dockerfile.replace(/\\\r?\n/g, ' ').split(/\r?\n/).map((line) => line.trim()).filter((line) => !!line && !line.startsWith('#'));
+    const variables = {};
+    const stages = new Set();
+    const images = [];
+    let beforeFirstFrom = true;
+    for (const instruction of instructions) {
+        const [keyword, ...rest] = instruction.split(/\s+/);
+        if (keyword.toUpperCase() === 'ARG' && beforeFirstFrom) {
+            for (const declaration of rest) {
+                const [name, value] = declaration.split(/=(.*)/s);
+                if (buildargs[name] !== undefined)
+                    variables[name] = buildargs[name];
+                else if (value !== undefined)
+                    variables[name] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+        if (keyword.toUpperCase() !== 'FROM')
+            continue;
+        beforeFirstFrom = false;
+        const words = rest.filter((word) => !word.startsWith('--'));
+        const [reference, as, stage] = words;
+        if (as?.toUpperCase() === 'AS' && stage)
+            stages.add(stage.toLowerCase());
+        if (!reference)
+            continue;
+        let unknown = false;
+        const image = reference.replace(/\$\{?([A-Za-z_][A-Za-z0-9_]*)}?/g, (_, name) => {
+            if (variables[name] === undefined)
+                unknown = true;
+            return variables[name] ?? '';
+        });
+        if (unknown || !image || image.toLowerCase() === 'scratch' || stages.has(image.toLowerCase()) || images.includes(image))
+            continue;
+        images.push(image);
+    }
+    return images;
+}

package/dist/cjs/docker/lib/ParseEnvToRecord.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn a list of environment variables as the Engine API gives them (`['PATH=/usr/bin', 'MODE=a=b']`) into a record by
+ * name. A variable is split at its first `=`; an entry without `=` is skipped; a repeated name keeps its last value.
+ * @param rawEnv The `NAME=value` entries; `null` or `undefined` for none.
+ * @returns The values by name (`{PATH: '/usr/bin', MODE: 'a=b'}`).
+ * @example
+ * ```typescript
+ * import {parseEnvToRecord} from 'lakutata/com/docker'
+ *
+ * const env: Record<string, string> = parseEnvToRecord(['PATH=/usr/bin', 'MODE=a=b', 'EMPTY='])
+ * console.log(env) //{PATH: '/usr/bin', MODE: 'a=b', EMPTY: ''}
+ * ```
+ */
+export declare function parseEnvToRecord(rawEnv?: string[] | null): Record<string, string>;

package/dist/cjs/docker/lib/ParseEnvToRecord.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnvToRecord = parseEnvToRecord;
+/**
+ * Turn a list of environment variables as the Engine API gives them (`['PATH=/usr/bin', 'MODE=a=b']`) into a record by
+ * name. A variable is split at its first `=`; an entry without `=` is skipped; a repeated name keeps its last value.
+ * @param rawEnv The `NAME=value` entries; `null` or `undefined` for none.
+ * @returns The values by name (`{PATH: '/usr/bin', MODE: 'a=b'}`).
+ * @example
+ * ```typescript
+ * import {parseEnvToRecord} from 'lakutata/com/docker'
+ *
+ * const env: Record<string, string> = parseEnvToRecord(['PATH=/usr/bin', 'MODE=a=b', 'EMPTY='])
+ * console.log(env) //{PATH: '/usr/bin', MODE: 'a=b', EMPTY: ''}
+ * ```
+ */
+function parseEnvToRecord(rawEnv) {
+    const environments = {};
+    for (const envString of rawEnv ?? []) {
+        const splitPos = envString.indexOf('=');
+        if (splitPos !== -1)
+            environments[envString.substring(0, splitPos)] = envString.substring(splitPos + 1);
+    }
+    return environments;
+}

package/dist/cjs/docker/lib/ParseRepositoryTag.d.ts

@@ -0,0 +1,17 @@
+import { type RepositoryTag } from '../types/RepositoryTag.js';
+/**
+ * Split an image reference into its repository and its tag (or digest). A digest (`@`) wins over a tag; the port of a
+ * registry (`registry:5000/app`) is not taken for a tag.
+ * @param input The image reference: `alpine`, `alpine:3.20`, `registry.example.com:5000/team/app:1.0`,
+ * `alpine@sha256:…`.
+ * @returns The repository, and the tag (or the digest, without its `@`) when the reference has one.
+ * @example
+ * ```typescript
+ * import {parseRepositoryTag, type RepositoryTag} from 'lakutata/com/docker'
+ *
+ * const reference: RepositoryTag = parseRepositoryTag('registry.example.com:5000/team/app:1.0')
+ * console.log(reference) //{repo: 'registry.example.com:5000/team/app', tag: '1.0'}
+ * console.log(parseRepositoryTag('registry.example.com:5000/team/app')) //{repo: 'registry.example.com:5000/team/app'}
+ * ```
+ */
+export declare function parseRepositoryTag(input: string): RepositoryTag;

package/dist/cjs/docker/lib/ParseRepositoryTag.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRepositoryTag = parseRepositoryTag;
+/**
+ * Split an image reference into its repository and its tag (or digest). A digest (`@`) wins over a tag; the port of a
+ * registry (`registry:5000/app`) is not taken for a tag.
+ * @param input The image reference: `alpine`, `alpine:3.20`, `registry.example.com:5000/team/app:1.0`,
+ * `alpine@sha256:…`.
+ * @returns The repository, and the tag (or the digest, without its `@`) when the reference has one.
+ * @example
+ * ```typescript
+ * import {parseRepositoryTag, type RepositoryTag} from 'lakutata/com/docker'
+ *
+ * const reference: RepositoryTag = parseRepositoryTag('registry.example.com:5000/team/app:1.0')
+ * console.log(reference) //{repo: 'registry.example.com:5000/team/app', tag: '1.0'}
+ * console.log(parseRepositoryTag('registry.example.com:5000/team/app')) //{repo: 'registry.example.com:5000/team/app'}
+ * ```
+ */
+function parseRepositoryTag(input) {
+    let separatorPos;
+    const digestPos = input.indexOf('@');
+    const colonPos = input.lastIndexOf(':');
+    // @ symbol is more important
+    if (digestPos >= 0) {
+        separatorPos = digestPos;
+    }
+    else if (colonPos >= 0) {
+        separatorPos = colonPos;
+    }
+    else {
+        // no colon nor @
+        return {
+            repo: input
+        };
+    }
+    // last colon is either the tag (or part of a port designation)
+    const tag = input.slice(separatorPos + 1);
+    // if it contains a / its not a tag and is part of the url
+    if (tag.indexOf('/') === -1) {
+        return {
+            repo: input.slice(0, separatorPos),
+            tag: tag
+        };
+    }
+    return {
+        repo: input
+    };
+}

package/dist/cjs/docker/lib/RegistryAuth.d.ts

@@ -0,0 +1,8 @@
+import { type DockerRegistryAuth } from '../../client/DockerClient.js';
+import { type DockerAuthOptions } from '../options/auth/DockerAuthOptions.js';
+/**
+ * The registry credentials sent to the daemon (the login, the pulls, the pushes and the builds), the tokens included
+ * @param auth
+ */
+export declare function registryAuth(auth: DockerAuthOptions): DockerRegistryAuth;
+export declare function registryAuth(auth?: DockerAuthOptions): DockerRegistryAuth | undefined;

package/dist/cjs/docker/lib/RegistryAuth.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registryAuth = registryAuth;
+function registryAuth(auth) {
+    if (!auth)
+        return undefined;
+    return {
+        username: auth.username,
+        password: auth.password,
+        serveraddress: auth.serverAddress,
+        email: auth.email,
+        identitytoken: auth.identityToken,
+        registrytoken: auth.registryToken
+    };
+}

package/dist/cjs/docker/options/DockerPruneOptions.d.ts

@@ -0,0 +1,38 @@
+import { DTO } from '@lakutata/core';
+/**
+ * Which unused resources {@link Docker.prune} removes, each kind as its `docker … prune` command does without options.
+ * Called without options, it prunes the containers and the images; the networks and the volumes only when asked (the
+ * volumes, as `docker system prune --volumes`).
+ * @example
+ * ```typescript
+ * import {Docker} from 'lakutata/com/docker'
+ *
+ * declare const docker: Docker
+ *
+ * //The stopped containers and the unused networks, keeping the images and the volumes
+ * await docker.prune({containers: true, images: false, networks: true, volumes: false})
+ * ```
+ */
+export declare class DockerPruneOptions extends DTO {
+    /**
+     * Remove the stopped containers (`docker container prune`).
+     * @default true
+     */
+    containers?: boolean;
+    /**
+     * Remove the dangling images, untagged and not used by a container (`docker image prune`, without `--all`).
+     * @default true
+     */
+    images?: boolean;
+    /**
+     * Remove the networks no container uses (`docker network prune`).
+     * @default false
+     */
+    networks?: boolean;
+    /**
+     * Remove the volumes no container uses (`docker volume prune`): the anonymous ones only on Docker Engine 23 and
+     * later (API 1.42), the named ones too before.
+     * @default false
+     */
+    volumes?: boolean;
+}