@git.zone/tsdocker 1.2.43 → 1.4.0

package/cli.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-require('./dist/index');
+import('./dist_ts/index.js');

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@git.zone/tsdocker',
+    version: '1.4.0',
+    description: 'develop npm modules cross platform with docker'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxvQkFBb0I7SUFDMUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGdEQUFnRDtDQUM5RCxDQUFBIn0=

package/dist_ts/classes.dockerfile.d.ts

@@ -0,0 +1,85 @@
+import { DockerRegistry } from './classes.dockerregistry.js';
+import type { IDockerfileOptions } from './interfaces/index.js';
+import type { TsDockerManager } from './classes.tsdockermanager.js';
+/**
+ * Class Dockerfile represents a Dockerfile on disk
+ */
+export declare class Dockerfile {
+    /**
+     * Creates instances of class Dockerfile for all Dockerfiles in cwd
+     */
+    static readDockerfiles(managerRef: TsDockerManager): Promise<Dockerfile[]>;
+    /**
+     * Sorts Dockerfiles into a build order based on dependencies (topological sort)
+     */
+    static sortDockerfiles(dockerfiles: Dockerfile[]): Promise<Dockerfile[]>;
+    /**
+     * Maps local Dockerfiles dependencies to the corresponding Dockerfile class instances
+     */
+    static mapDockerfiles(sortedDockerfileArray: Dockerfile[]): Promise<Dockerfile[]>;
+    /**
+     * Builds the corresponding real docker image for each Dockerfile class instance
+     */
+    static buildDockerfiles(sortedArrayArg: Dockerfile[]): Promise<Dockerfile[]>;
+    /**
+     * Tests all Dockerfiles by calling Dockerfile.test()
+     */
+    static testDockerfiles(sortedArrayArg: Dockerfile[]): Promise<Dockerfile[]>;
+    /**
+     * Returns a version for a docker file
+     * Dockerfile_latest -> latest
+     * Dockerfile_v1.0.0 -> v1.0.0
+     * Dockerfile -> latest
+     */
+    static dockerFileVersion(dockerfileInstanceArg: Dockerfile, dockerfileNameArg: string): string;
+    /**
+     * Extracts the base image from a Dockerfile content
+     * Handles ARG substitution for variable base images
+     */
+    static dockerBaseImage(dockerfileContentArg: string): string;
+    /**
+     * Substitutes variables in a string, supporting default values like ${VAR:-default}
+     */
+    private static substituteVariables;
+    /**
+     * Returns the docker tag string for a given registry and repo
+     */
+    static getDockerTagString(managerRef: TsDockerManager, registryArg: string, repoArg: string, versionArg: string, suffixArg?: string): string;
+    /**
+     * Gets build args from environment variable mapping
+     */
+    static getDockerBuildArgs(managerRef: TsDockerManager): Promise<string>;
+    managerRef: TsDockerManager;
+    filePath: string;
+    repo: string;
+    version: string;
+    cleanTag: string;
+    buildTag: string;
+    pushTag: string;
+    containerName: string;
+    content: string;
+    baseImage: string;
+    localBaseImageDependent: boolean;
+    localBaseDockerfile: Dockerfile;
+    constructor(managerRefArg: TsDockerManager, options: IDockerfileOptions);
+    /**
+     * Builds the Dockerfile
+     */
+    build(): Promise<void>;
+    /**
+     * Pushes the Dockerfile to a registry
+     */
+    push(dockerRegistryArg: DockerRegistry, versionSuffix?: string): Promise<void>;
+    /**
+     * Pulls the Dockerfile from a registry
+     */
+    pull(registryArg: DockerRegistry, versionSuffixArg?: string): Promise<void>;
+    /**
+     * Tests the Dockerfile by running a test script if it exists
+     */
+    test(): Promise<void>;
+    /**
+     * Gets the ID of a built Docker image
+     */
+    getId(): Promise<string>;
+}

package/dist_ts/classes.dockerfile.js

@@ -0,0 +1,366 @@
+import * as plugins from './tsdocker.plugins.js';
+import * as paths from './tsdocker.paths.js';
+import { logger } from './tsdocker.logging.js';
+import { DockerRegistry } from './classes.dockerregistry.js';
+const smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+});
+/**
+ * Class Dockerfile represents a Dockerfile on disk
+ */
+export class Dockerfile {
+    // STATIC METHODS
+    /**
+     * Creates instances of class Dockerfile for all Dockerfiles in cwd
+     */
+    static async readDockerfiles(managerRef) {
+        const entries = await plugins.smartfs.directory(paths.cwd).filter('Dockerfile*').list();
+        const fileTree = entries
+            .filter(entry => entry.isFile)
+            .map(entry => plugins.path.join(paths.cwd, entry.name));
+        const readDockerfilesArray = [];
+        logger.log('info', `found ${fileTree.length} Dockerfiles:`);
+        console.log(fileTree);
+        for (const dockerfilePath of fileTree) {
+            const myDockerfile = new Dockerfile(managerRef, {
+                filePath: dockerfilePath,
+                read: true,
+            });
+            readDockerfilesArray.push(myDockerfile);
+        }
+        return readDockerfilesArray;
+    }
+    /**
+     * Sorts Dockerfiles into a build order based on dependencies (topological sort)
+     */
+    static async sortDockerfiles(dockerfiles) {
+        logger.log('info', 'Sorting Dockerfiles based on dependencies...');
+        // Map from cleanTag to Dockerfile instance for quick lookup
+        const tagToDockerfile = new Map();
+        dockerfiles.forEach((dockerfile) => {
+            tagToDockerfile.set(dockerfile.cleanTag, dockerfile);
+        });
+        // Build the dependency graph
+        const graph = new Map();
+        dockerfiles.forEach((dockerfile) => {
+            const dependencies = [];
+            const baseImage = dockerfile.baseImage;
+            // Check if the baseImage is among the local Dockerfiles
+            if (tagToDockerfile.has(baseImage)) {
+                const baseDockerfile = tagToDockerfile.get(baseImage);
+                dependencies.push(baseDockerfile);
+                dockerfile.localBaseImageDependent = true;
+                dockerfile.localBaseDockerfile = baseDockerfile;
+            }
+            graph.set(dockerfile, dependencies);
+        });
+        // Perform topological sort
+        const sortedDockerfiles = [];
+        const visited = new Set();
+        const tempMarked = new Set();
+        const visit = (dockerfile) => {
+            if (tempMarked.has(dockerfile)) {
+                throw new Error(`Circular dependency detected involving ${dockerfile.cleanTag}`);
+            }
+            if (!visited.has(dockerfile)) {
+                tempMarked.add(dockerfile);
+                const dependencies = graph.get(dockerfile) || [];
+                dependencies.forEach((dep) => visit(dep));
+                tempMarked.delete(dockerfile);
+                visited.add(dockerfile);
+                sortedDockerfiles.push(dockerfile);
+            }
+        };
+        try {
+            dockerfiles.forEach((dockerfile) => {
+                if (!visited.has(dockerfile)) {
+                    visit(dockerfile);
+                }
+            });
+        }
+        catch (error) {
+            logger.log('error', error.message);
+            throw error;
+        }
+        // Log the sorted order
+        sortedDockerfiles.forEach((dockerfile, index) => {
+            logger.log('info', `Build order ${index + 1}: ${dockerfile.cleanTag} with base image ${dockerfile.baseImage}`);
+        });
+        return sortedDockerfiles;
+    }
+    /**
+     * Maps local Dockerfiles dependencies to the corresponding Dockerfile class instances
+     */
+    static async mapDockerfiles(sortedDockerfileArray) {
+        sortedDockerfileArray.forEach((dockerfileArg) => {
+            if (dockerfileArg.localBaseImageDependent) {
+                sortedDockerfileArray.forEach((dockfile2) => {
+                    if (dockfile2.cleanTag === dockerfileArg.baseImage) {
+                        dockerfileArg.localBaseDockerfile = dockfile2;
+                    }
+                });
+            }
+        });
+        return sortedDockerfileArray;
+    }
+    /**
+     * Builds the corresponding real docker image for each Dockerfile class instance
+     */
+    static async buildDockerfiles(sortedArrayArg) {
+        for (const dockerfileArg of sortedArrayArg) {
+            await dockerfileArg.build();
+        }
+        return sortedArrayArg;
+    }
+    /**
+     * Tests all Dockerfiles by calling Dockerfile.test()
+     */
+    static async testDockerfiles(sortedArrayArg) {
+        for (const dockerfileArg of sortedArrayArg) {
+            await dockerfileArg.test();
+        }
+        return sortedArrayArg;
+    }
+    /**
+     * Returns a version for a docker file
+     * Dockerfile_latest -> latest
+     * Dockerfile_v1.0.0 -> v1.0.0
+     * Dockerfile -> latest
+     */
+    static dockerFileVersion(dockerfileInstanceArg, dockerfileNameArg) {
+        let versionString;
+        const versionRegex = /Dockerfile_(.+)$/;
+        const regexResultArray = versionRegex.exec(dockerfileNameArg);
+        if (regexResultArray && regexResultArray.length === 2) {
+            versionString = regexResultArray[1];
+        }
+        else {
+            versionString = 'latest';
+        }
+        // Replace ##version## placeholder with actual package version if available
+        if (dockerfileInstanceArg.managerRef?.projectInfo?.npm?.version) {
+            versionString = versionString.replace('##version##', dockerfileInstanceArg.managerRef.projectInfo.npm.version);
+        }
+        return versionString;
+    }
+    /**
+     * Extracts the base image from a Dockerfile content
+     * Handles ARG substitution for variable base images
+     */
+    static dockerBaseImage(dockerfileContentArg) {
+        const lines = dockerfileContentArg.split(/\r?\n/);
+        const args = {};
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            // Skip empty lines and comments
+            if (trimmedLine === '' || trimmedLine.startsWith('#')) {
+                continue;
+            }
+            // Match ARG instructions
+            const argMatch = trimmedLine.match(/^ARG\s+([^\s=]+)(?:=(.*))?$/i);
+            if (argMatch) {
+                const argName = argMatch[1];
+                const argValue = argMatch[2] !== undefined ? argMatch[2] : process.env[argName] || '';
+                args[argName] = argValue;
+                continue;
+            }
+            // Match FROM instructions
+            const fromMatch = trimmedLine.match(/^FROM\s+(.+?)(?:\s+AS\s+[^\s]+)?$/i);
+            if (fromMatch) {
+                let baseImage = fromMatch[1].trim();
+                // Substitute variables in the base image name
+                baseImage = Dockerfile.substituteVariables(baseImage, args);
+                return baseImage;
+            }
+        }
+        throw new Error('No FROM instruction found in Dockerfile');
+    }
+    /**
+     * Substitutes variables in a string, supporting default values like ${VAR:-default}
+     */
+    static substituteVariables(str, vars) {
+        return str.replace(/\${([^}:]+)(:-([^}]+))?}/g, (_, varName, __, defaultValue) => {
+            if (vars[varName] !== undefined) {
+                return vars[varName];
+            }
+            else if (defaultValue !== undefined) {
+                return defaultValue;
+            }
+            else {
+                return '';
+            }
+        });
+    }
+    /**
+     * Returns the docker tag string for a given registry and repo
+     */
+    static getDockerTagString(managerRef, registryArg, repoArg, versionArg, suffixArg) {
+        // Determine whether the repo should be mapped according to the registry
+        const config = managerRef.config;
+        const mappedRepo = config.registryRepoMap?.[registryArg];
+        const repo = mappedRepo || repoArg;
+        // Determine whether the version contains a suffix
+        let version = versionArg;
+        if (suffixArg) {
+            version = versionArg + '_' + suffixArg;
+        }
+        const tagString = `${registryArg}/${repo}:${version}`;
+        return tagString;
+    }
+    /**
+     * Gets build args from environment variable mapping
+     */
+    static async getDockerBuildArgs(managerRef) {
+        logger.log('info', 'checking for env vars to be supplied to the docker build');
+        let buildArgsString = '';
+        const config = managerRef.config;
+        if (config.buildArgEnvMap) {
+            for (const dockerArgKey of Object.keys(config.buildArgEnvMap)) {
+                const dockerArgOuterEnvVar = config.buildArgEnvMap[dockerArgKey];
+                logger.log('note', `docker ARG "${dockerArgKey}" maps to outer env var "${dockerArgOuterEnvVar}"`);
+                const targetValue = process.env[dockerArgOuterEnvVar];
+                if (targetValue) {
+                    buildArgsString = `${buildArgsString} --build-arg ${dockerArgKey}="${targetValue}"`;
+                }
+            }
+        }
+        return buildArgsString;
+    }
+    // INSTANCE PROPERTIES
+    managerRef;
+    filePath;
+    repo;
+    version;
+    cleanTag;
+    buildTag;
+    pushTag;
+    containerName;
+    content;
+    baseImage;
+    localBaseImageDependent;
+    localBaseDockerfile;
+    constructor(managerRefArg, options) {
+        this.managerRef = managerRefArg;
+        this.filePath = options.filePath;
+        // Build repo name from project info or directory name
+        const projectInfo = this.managerRef.projectInfo;
+        if (projectInfo?.npm?.name) {
+            // Use package name, removing scope if present
+            const packageName = projectInfo.npm.name.replace(/^@[^/]+\//, '');
+            this.repo = packageName;
+        }
+        else {
+            // Fallback to directory name
+            this.repo = plugins.path.basename(paths.cwd);
+        }
+        this.version = Dockerfile.dockerFileVersion(this, plugins.path.parse(this.filePath).base);
+        this.cleanTag = this.repo + ':' + this.version;
+        this.buildTag = this.cleanTag;
+        this.containerName = 'dockerfile-' + this.version;
+        if (options.filePath && options.read) {
+            const fs = require('fs');
+            this.content = fs.readFileSync(plugins.path.resolve(options.filePath), 'utf-8');
+        }
+        else if (options.fileContents) {
+            this.content = options.fileContents;
+        }
+        this.baseImage = Dockerfile.dockerBaseImage(this.content);
+        this.localBaseImageDependent = false;
+    }
+    /**
+     * Builds the Dockerfile
+     */
+    async build() {
+        logger.log('info', 'now building Dockerfile for ' + this.cleanTag);
+        const buildArgsString = await Dockerfile.getDockerBuildArgs(this.managerRef);
+        const config = this.managerRef.config;
+        let buildCommand;
+        // Check if multi-platform build is needed
+        if (config.platforms && config.platforms.length > 1) {
+            // Multi-platform build using buildx
+            const platformString = config.platforms.join(',');
+            buildCommand = `docker buildx build --platform ${platformString} -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
+            if (config.push) {
+                buildCommand += ' --push';
+            }
+            else {
+                buildCommand += ' --load';
+            }
+        }
+        else {
+            // Standard build
+            const versionLabel = this.managerRef.projectInfo?.npm?.version || 'unknown';
+            buildCommand = `docker build --label="version=${versionLabel}" -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
+        }
+        const result = await smartshellInstance.exec(buildCommand);
+        if (result.exitCode !== 0) {
+            logger.log('error', `Build failed for ${this.cleanTag}`);
+            console.log(result.stdout);
+            throw new Error(`Build failed for ${this.cleanTag}`);
+        }
+        logger.log('ok', `Built ${this.cleanTag}`);
+    }
+    /**
+     * Pushes the Dockerfile to a registry
+     */
+    async push(dockerRegistryArg, versionSuffix) {
+        this.pushTag = Dockerfile.getDockerTagString(this.managerRef, dockerRegistryArg.registryUrl, this.repo, this.version, versionSuffix);
+        await smartshellInstance.exec(`docker tag ${this.buildTag} ${this.pushTag}`);
+        const pushResult = await smartshellInstance.exec(`docker push ${this.pushTag}`);
+        if (pushResult.exitCode !== 0) {
+            logger.log('error', `Push failed for ${this.pushTag}`);
+            throw new Error(`Push failed for ${this.pushTag}`);
+        }
+        // Get image digest
+        const inspectResult = await smartshellInstance.exec(`docker inspect --format="{{index .RepoDigests 0}}" ${this.pushTag}`);
+        if (inspectResult.exitCode === 0 && inspectResult.stdout.includes('@')) {
+            const imageDigest = inspectResult.stdout.split('@')[1]?.trim();
+            console.log(`The image ${this.pushTag} has digest ${imageDigest}`);
+        }
+        logger.log('ok', `Pushed ${this.pushTag}`);
+    }
+    /**
+     * Pulls the Dockerfile from a registry
+     */
+    async pull(registryArg, versionSuffixArg) {
+        const pullTag = Dockerfile.getDockerTagString(this.managerRef, registryArg.registryUrl, this.repo, this.version, versionSuffixArg);
+        await smartshellInstance.exec(`docker pull ${pullTag}`);
+        await smartshellInstance.exec(`docker tag ${pullTag} ${this.buildTag}`);
+        logger.log('ok', `Pulled and tagged ${pullTag} as ${this.buildTag}`);
+    }
+    /**
+     * Tests the Dockerfile by running a test script if it exists
+     */
+    async test() {
+        const testDir = this.managerRef.config.testDir || plugins.path.join(paths.cwd, 'test');
+        const testFile = plugins.path.join(testDir, 'test_' + this.version + '.sh');
+        const fs = require('fs');
+        const testFileExists = fs.existsSync(testFile);
+        if (testFileExists) {
+            logger.log('info', `Running tests for ${this.cleanTag}`);
+            // Run tests in container
+            await smartshellInstance.exec(`docker run --name tsdocker_test_container --entrypoint="bash" ${this.buildTag} -c "mkdir /tsdocker_test"`);
+            await smartshellInstance.exec(`docker cp ${testFile} tsdocker_test_container:/tsdocker_test/test.sh`);
+            await smartshellInstance.exec(`docker commit tsdocker_test_container tsdocker_test_image`);
+            const testResult = await smartshellInstance.exec(`docker run --entrypoint="bash" tsdocker_test_image -x /tsdocker_test/test.sh`);
+            // Cleanup
+            await smartshellInstance.exec(`docker rm tsdocker_test_container`);
+            await smartshellInstance.exec(`docker rmi --force tsdocker_test_image`);
+            if (testResult.exitCode !== 0) {
+                throw new Error(`Tests failed for ${this.cleanTag}`);
+            }
+            logger.log('ok', `Tests passed for ${this.cleanTag}`);
+        }
+        else {
+            logger.log('warn', `Skipping tests for ${this.cleanTag} because no test file was found at ${testFile}`);
+        }
+    }
+    /**
+     * Gets the ID of a built Docker image
+     */
+    async getId() {
+        const result = await smartshellInstance.exec('docker inspect --type=image --format="{{.Id}}" ' + this.buildTag);
+        return result.stdout.trim();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dockerfile.js","sourceRoot":"","sources":["../ts/classes.dockerfile.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.dockerregistry.d.ts

@@ -0,0 +1,29 @@
+import type { IDockerRegistryOptions } from './interfaces/index.js';
+/**
+ * Represents a Docker registry with authentication capabilities
+ */
+export declare class DockerRegistry {
+    registryUrl: string;
+    username: string;
+    password: string;
+    constructor(optionsArg: IDockerRegistryOptions);
+    /**
+     * Creates a DockerRegistry instance from a pipe-delimited environment string
+     * Format: "registryUrl|username|password"
+     */
+    static fromEnvString(envString: string): DockerRegistry;
+    /**
+     * Creates a DockerRegistry from environment variables
+     * Looks for DOCKER_REGISTRY, DOCKER_REGISTRY_USER, DOCKER_REGISTRY_PASSWORD
+     * Or for a specific registry: DOCKER_REGISTRY_<NAME>, etc.
+     */
+    static fromEnv(registryName?: string): DockerRegistry | null;
+    /**
+     * Logs in to the Docker registry
+     */
+    login(): Promise<void>;
+    /**
+     * Logs out from the Docker registry
+     */
+    logout(): Promise<void>;
+}

package/dist_ts/classes.dockerregistry.js

@@ -0,0 +1,83 @@
+import * as plugins from './tsdocker.plugins.js';
+import { logger } from './tsdocker.logging.js';
+const smartshellInstance = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+});
+/**
+ * Represents a Docker registry with authentication capabilities
+ */
+export class DockerRegistry {
+    registryUrl;
+    username;
+    password;
+    constructor(optionsArg) {
+        this.registryUrl = optionsArg.registryUrl;
+        this.username = optionsArg.username;
+        this.password = optionsArg.password;
+        logger.log('info', `created DockerRegistry for ${this.registryUrl}`);
+    }
+    /**
+     * Creates a DockerRegistry instance from a pipe-delimited environment string
+     * Format: "registryUrl|username|password"
+     */
+    static fromEnvString(envString) {
+        const dockerRegexResultArray = envString.split('|');
+        if (dockerRegexResultArray.length !== 3) {
+            logger.log('error', 'malformed docker env var...');
+            throw new Error('malformed docker env var, expected format: registryUrl|username|password');
+        }
+        const registryUrl = dockerRegexResultArray[0].replace('https://', '').replace('http://', '');
+        const username = dockerRegexResultArray[1];
+        const password = dockerRegexResultArray[2];
+        return new DockerRegistry({
+            registryUrl: registryUrl,
+            username: username,
+            password: password,
+        });
+    }
+    /**
+     * Creates a DockerRegistry from environment variables
+     * Looks for DOCKER_REGISTRY, DOCKER_REGISTRY_USER, DOCKER_REGISTRY_PASSWORD
+     * Or for a specific registry: DOCKER_REGISTRY_<NAME>, etc.
+     */
+    static fromEnv(registryName) {
+        const prefix = registryName ? `DOCKER_REGISTRY_${registryName.toUpperCase()}_` : 'DOCKER_REGISTRY_';
+        const registryUrl = process.env[`${prefix}URL`] || process.env['DOCKER_REGISTRY'];
+        const username = process.env[`${prefix}USER`] || process.env['DOCKER_REGISTRY_USER'];
+        const password = process.env[`${prefix}PASSWORD`] || process.env['DOCKER_REGISTRY_PASSWORD'];
+        if (!registryUrl || !username || !password) {
+            return null;
+        }
+        return new DockerRegistry({
+            registryUrl: registryUrl.replace('https://', '').replace('http://', ''),
+            username,
+            password,
+        });
+    }
+    /**
+     * Logs in to the Docker registry
+     */
+    async login() {
+        if (this.registryUrl === 'docker.io') {
+            await smartshellInstance.exec(`docker login -u ${this.username} -p ${this.password}`);
+            logger.log('info', 'Logged in to standard docker hub');
+        }
+        else {
+            await smartshellInstance.exec(`docker login -u ${this.username} -p ${this.password} ${this.registryUrl}`);
+        }
+        logger.log('ok', `docker authenticated for ${this.registryUrl}!`);
+    }
+    /**
+     * Logs out from the Docker registry
+     */
+    async logout() {
+        if (this.registryUrl === 'docker.io') {
+            await smartshellInstance.exec('docker logout');
+        }
+        else {
+            await smartshellInstance.exec(`docker logout ${this.registryUrl}`);
+        }
+        logger.log('info', `logged out from ${this.registryUrl}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.registrystorage.d.ts

@@ -0,0 +1,35 @@
+import * as plugins from './tsdocker.plugins.js';
+import { DockerRegistry } from './classes.dockerregistry.js';
+/**
+ * Storage class for managing multiple Docker registries
+ */
+export declare class RegistryStorage {
+    objectMap: plugins.lik.ObjectMap<DockerRegistry>;
+    constructor();
+    /**
+     * Adds a registry to the storage
+     */
+    addRegistry(registryArg: DockerRegistry): void;
+    /**
+     * Gets a registry by its URL
+     */
+    getRegistryByUrl(registryUrlArg: string): DockerRegistry | undefined;
+    /**
+     * Gets all registries
+     */
+    getAllRegistries(): DockerRegistry[];
+    /**
+     * Logs in to all registries
+     */
+    loginAll(): Promise<void>;
+    /**
+     * Logs out from all registries
+     */
+    logoutAll(): Promise<void>;
+    /**
+     * Loads registries from environment variables
+     * Looks for DOCKER_REGISTRY_1, DOCKER_REGISTRY_2, etc. (pipe-delimited format)
+     * Or individual registries like DOCKER_REGISTRY_GITLAB_URL, etc.
+     */
+    loadFromEnv(): void;
+}