@serve.zone/appstore 0.2.0

package/dist_ts_client/classes.appstoreresolver.js

@@ -0,0 +1,513 @@
+export class AppStoreResolver {
+    baseUrl;
+    fetchRef;
+    resolveDockerDigests;
+    now;
+    appStoreCache = null;
+    sourceAppCache = new Map();
+    constructor(optionsArg = {}) {
+        this.baseUrl = optionsArg.baseUrl || 'https://code.foss.global/serve.zone/appstore/raw/branch/main';
+        this.fetchRef = optionsArg.fetch || fetch;
+        this.resolveDockerDigests = optionsArg.resolveDockerDigests ?? true;
+        this.now = optionsArg.now || (() => new Date());
+    }
+    async getAppStoreIndex() {
+        if (this.appStoreCache) {
+            return this.appStoreCache;
+        }
+        const appStore = await this.fetchAppStoreIndex();
+        this.appStoreCache = await this.resolveAppStore(appStore);
+        return this.appStoreCache;
+    }
+    async getApps() {
+        return (await this.getAppStoreIndex()).apps;
+    }
+    async getAppMeta(appIdArg) {
+        const app = await this.getAppStoreApp(appIdArg);
+        if (app?.source?.type === 'repoManifest') {
+            return (await this.resolveRepoManifestSource(app.source, app)).appMeta;
+        }
+        if (app?.source?.type === 'dockerImage') {
+            return this.createAppMetaFromAppStoreApp(app);
+        }
+        return await this.fetchJson(`apps/${appIdArg}/app.json`);
+    }
+    async getAppVersionConfig(appIdArg, versionArg) {
+        const app = await this.getAppStoreApp(appIdArg);
+        if (app?.source?.type === 'repoManifest') {
+            const resolvedApp = await this.resolveRepoManifestSource(app.source, app);
+            const config = resolvedApp.configsByVersion.get(versionArg);
+            if (!config) {
+                throw new Error(`Version '${versionArg}' is not defined by the linked appstore manifest`);
+            }
+            this.validateAppStoreVersionConfig(config, `${appIdArg}@${versionArg}`);
+            return config;
+        }
+        if (app?.source?.type === 'dockerImage' && app.runtime) {
+            const config = { ...app.runtime };
+            await this.applyDockerImageSourceToConfig(app.source, config, versionArg);
+            this.validateAppStoreVersionConfig(config, `${appIdArg}@${versionArg}`);
+            return config;
+        }
+        let config;
+        try {
+            config = await this.fetchJson(`apps/${appIdArg}/versions/${versionArg}/config.json`);
+        }
+        catch (error) {
+            if (app?.source?.type !== 'dockerImage') {
+                throw error;
+            }
+            const appMeta = await this.fetchJson(`apps/${appIdArg}/app.json`);
+            config = await this.fetchJson(`apps/${appIdArg}/versions/${appMeta.latestVersion}/config.json`);
+        }
+        if (app?.source?.type === 'dockerImage') {
+            await this.applyDockerImageSourceToConfig(app.source, config, versionArg);
+        }
+        this.validateAppStoreVersionConfig(config, `${appIdArg}@${versionArg}`);
+        return config;
+    }
+    async resolveAppStore(appStoreArg) {
+        const appStore = parseAppStoreIndex(appStoreArg);
+        this.sourceAppCache.clear();
+        const apps = [];
+        for (const app of appStore.apps) {
+            apps.push(await this.resolveAppStoreApp(app));
+        }
+        return {
+            ...appStore,
+            apps,
+            resolvedAt: this.now().toISOString(),
+        };
+    }
+    async resolveRepoManifestSource(sourceArg, appArg) {
+        const cacheKey = `${sourceArg.url}#${sourceArg.ref || ''}`;
+        const cachedApp = this.sourceAppCache.get(cacheKey);
+        if (cachedApp) {
+            return cachedApp;
+        }
+        const manifestText = await this.fetchTextFromUrl(sourceArg.url);
+        const manifestHash = await createSha256Hex(manifestText);
+        const manifest = parseServezoneAppStoreManifest(JSON.parse(manifestText));
+        const resolvedApp = await this.resolveServezoneAppStoreManifest(manifest, {
+            type: 'repoManifest',
+            url: sourceArg.url,
+            ref: sourceArg.ref,
+            manifestHash,
+            resolvedAt: this.now().toISOString(),
+        });
+        if (appArg) {
+            resolvedApp.appStoreApp = {
+                ...resolvedApp.appStoreApp,
+                ...withoutUndefined(appArg),
+                latestVersion: resolvedApp.appStoreApp.latestVersion,
+                versions: resolvedApp.appStoreApp.versions,
+                source: appArg.source,
+                tags: appArg.tags || resolvedApp.appStoreApp.tags,
+                resolvedSource: resolvedApp.appStoreApp.resolvedSource,
+            };
+            resolvedApp.appMeta = {
+                ...resolvedApp.appMeta,
+                id: resolvedApp.appStoreApp.id,
+                name: resolvedApp.appStoreApp.name,
+                description: resolvedApp.appStoreApp.description,
+                category: resolvedApp.appStoreApp.category,
+                iconName: resolvedApp.appStoreApp.iconName,
+                latestVersion: resolvedApp.appStoreApp.latestVersion,
+                versions: resolvedApp.appStoreApp.versions || resolvedApp.appMeta.versions,
+                tags: resolvedApp.appStoreApp.tags,
+                source: appArg.source,
+                resolvedSource: resolvedApp.appStoreApp.resolvedSource,
+            };
+        }
+        this.sourceAppCache.set(cacheKey, resolvedApp);
+        return resolvedApp;
+    }
+    async resolveDockerImageSource(sourceArg) {
+        let imageDigest;
+        if (sourceArg.tracking === 'digest' && this.resolveDockerDigests) {
+            imageDigest = await this.resolveDockerImageDigest(sourceArg.image) || undefined;
+        }
+        return {
+            type: 'dockerImage',
+            image: sourceArg.image,
+            imageDigest,
+            resolvedAt: this.now().toISOString(),
+        };
+    }
+    async resolveDockerImageDigest(imageArg) {
+        const parsedImage = parseDockerImageReference(imageArg);
+        if (parsedImage.digest) {
+            return parsedImage.digest;
+        }
+        return await this.fetchDockerManifestDigest(parsedImage);
+    }
+    validateAppStoreVersionConfig(configArg, labelArg = 'appstore config') {
+        if (!configArg || typeof configArg !== 'object') {
+            throw new Error(`Invalid ${labelArg}: config must be an object`);
+        }
+        if (!configArg.image || typeof configArg.image !== 'string') {
+            throw new Error(`Invalid ${labelArg}: image is required`);
+        }
+        this.assertValidPort(configArg.port, `${labelArg} port`);
+        for (const envVar of configArg.envVars || []) {
+            if (!envVar.key || !/^[A-Z_][A-Z0-9_]*$/.test(envVar.key)) {
+                throw new Error(`Invalid ${labelArg}: env var key '${envVar.key}' is not valid`);
+            }
+            if (envVar.value !== undefined && typeof envVar.value !== 'string') {
+                throw new Error(`Invalid ${labelArg}: env var '${envVar.key}' value must be a string`);
+            }
+        }
+        this.normalizeVolumes(configArg.volumes);
+        this.validatePublishedPorts(configArg.publishedPorts || [], labelArg);
+    }
+    normalizeVolumes(volumesArg = []) {
+        return volumesArg.map((volumeArg) => {
+            if (typeof volumeArg === 'string') {
+                return { mountPath: volumeArg };
+            }
+            return volumeArg;
+        }).map((volumeArg, indexArg) => {
+            this.validateVolume(volumeArg, `volume ${indexArg + 1}`);
+            return volumeArg;
+        });
+    }
+    async fetchAppStoreIndex() {
+        try {
+            return await this.fetchJson('appstore.resolved.json');
+        }
+        catch {
+            return await this.fetchJson('appstore.json');
+        }
+    }
+    async resolveAppStoreApp(appArg) {
+        if (appArg.source?.type === 'repoManifest') {
+            const resolvedApp = await this.resolveRepoManifestSource(appArg.source, appArg);
+            return {
+                ...resolvedApp.appStoreApp,
+                ...withoutUndefined(appArg),
+                latestVersion: resolvedApp.appStoreApp.latestVersion,
+                versions: resolvedApp.appStoreApp.versions,
+                source: appArg.source,
+                tags: appArg.tags || resolvedApp.appStoreApp.tags,
+                resolvedSource: resolvedApp.appStoreApp.resolvedSource,
+            };
+        }
+        if (appArg.source?.type === 'dockerImage') {
+            const config = appArg.runtime ? { ...appArg.runtime } : undefined;
+            const resolvedSource = config
+                ? (await this.applyDockerImageSourceToConfig(appArg.source, config, appArg.latestVersion)).resolvedSource
+                : await this.resolveDockerImageSource(appArg.source);
+            const latestVersion = createAppStoreVersionForDockerSource(appArg.source, appArg.latestVersion, resolvedSource?.imageDigest);
+            return {
+                ...appArg,
+                runtime: config,
+                latestVersion,
+                versions: uniqueStrings([...(appArg.versions || []), latestVersion]),
+                upgradeStrategy: appArg.source.tracking === 'digest' ? 'dockerDigest' : appArg.upgradeStrategy,
+                resolvedSource,
+            };
+        }
+        return appArg;
+    }
+    async resolveServezoneAppStoreManifest(manifestArg, resolvedSourceArg) {
+        const configsByVersion = new Map();
+        const versions = [];
+        const sourceVersionToResolvedVersion = new Map();
+        for (const versionArg of manifestArg.versions || []) {
+            const sourceVersion = versionArg.version;
+            const { version: _version, ...versionConfig } = versionArg;
+            const config = {
+                ...versionConfig,
+                source: versionConfig.source || manifestArg.source,
+                resolvedSource: resolvedSourceArg,
+            };
+            await this.resolveConfigSource(config, sourceVersion);
+            const resolvedVersion = config.appStoreVersion || sourceVersion;
+            config.appStoreVersion = resolvedVersion;
+            this.validateAppStoreVersionConfig(config, `${manifestArg.app.id}@${resolvedVersion}`);
+            configsByVersion.set(resolvedVersion, config);
+            configsByVersion.set(sourceVersion, config);
+            versions.push(resolvedVersion);
+            sourceVersionToResolvedVersion.set(sourceVersion, resolvedVersion);
+        }
+        if (manifestArg.runtime) {
+            const sourceVersion = manifestArg.latestVersion || manifestArg.channel || 'latest';
+            const config = {
+                ...manifestArg.runtime,
+                source: manifestArg.runtime.source || manifestArg.source,
+                resolvedSource: resolvedSourceArg,
+            };
+            await this.resolveConfigSource(config, sourceVersion);
+            const resolvedVersion = config.appStoreVersion || sourceVersion;
+            config.appStoreVersion = resolvedVersion;
+            this.validateAppStoreVersionConfig(config, `${manifestArg.app.id}@${resolvedVersion}`);
+            configsByVersion.set(resolvedVersion, config);
+            configsByVersion.set(sourceVersion, config);
+            versions.push(resolvedVersion);
+            sourceVersionToResolvedVersion.set(sourceVersion, resolvedVersion);
+        }
+        if (configsByVersion.size === 0) {
+            throw new Error('Appstore manifest must define at least one runtime config or version');
+        }
+        const selectedChannel = manifestArg.policy?.defaultChannel || manifestArg.channel || 'stable';
+        const channelVersion = manifestArg.channels?.[selectedChannel];
+        const declaredLatestVersion = manifestArg.latestVersion || channelVersion || versions[versions.length - 1];
+        const latestVersion = sourceVersionToResolvedVersion.get(declaredLatestVersion) || declaredLatestVersion;
+        const uniqueVersions = uniqueStrings(versions);
+        const appStoreApp = {
+            id: manifestArg.app.id,
+            name: manifestArg.app.name,
+            description: manifestArg.app.description,
+            category: manifestArg.app.category,
+            iconName: manifestArg.app.iconName,
+            iconUrl: manifestArg.app.iconUrl,
+            latestVersion,
+            versions: uniqueVersions,
+            tags: manifestArg.app.tags,
+            channel: selectedChannel,
+            source: manifestArg.source,
+            upgradeStrategy: getUpgradeStrategyForConfig(configsByVersion.get(latestVersion)),
+            resolvedSource: resolvedSourceArg,
+        };
+        const appMeta = {
+            id: manifestArg.app.id,
+            name: manifestArg.app.name,
+            description: manifestArg.app.description,
+            category: manifestArg.app.category,
+            iconName: manifestArg.app.iconName,
+            latestVersion,
+            versions: uniqueVersions,
+            maintainer: manifestArg.app.maintainer,
+            links: manifestArg.app.links,
+            tags: manifestArg.app.tags,
+            source: manifestArg.source,
+            resolvedSource: resolvedSourceArg,
+        };
+        return { appStoreApp, appMeta, configsByVersion };
+    }
+    async resolveConfigSource(configArg, versionArg) {
+        if (configArg.source?.type === 'dockerImage') {
+            await this.applyDockerImageSourceToConfig(configArg.source, configArg, versionArg);
+        }
+    }
+    async applyDockerImageSourceToConfig(sourceArg, configArg, versionArg) {
+        configArg.image = sourceArg.image;
+        configArg.source = sourceArg;
+        const resolvedSource = await this.resolveDockerImageSource(sourceArg);
+        configArg.resolvedSource = resolvedSource;
+        configArg.resolvedImageDigest = resolvedSource.imageDigest;
+        configArg.upgradeStrategy = sourceArg.tracking === 'digest' ? 'dockerDigest' : configArg.upgradeStrategy;
+        configArg.appStoreVersion = createAppStoreVersionForDockerSource(sourceArg, versionArg, resolvedSource.imageDigest);
+        return configArg;
+    }
+    createAppMetaFromAppStoreApp(appArg) {
+        return {
+            id: appArg.id,
+            name: appArg.name,
+            description: appArg.description,
+            category: appArg.category,
+            iconName: appArg.iconName,
+            latestVersion: appArg.latestVersion,
+            versions: appArg.versions || [appArg.latestVersion],
+            tags: appArg.tags,
+            source: appArg.source,
+            resolvedSource: appArg.resolvedSource,
+        };
+    }
+    async getAppStoreApp(appIdArg) {
+        const appStore = await this.getAppStoreIndex();
+        return appStore.apps.find((appArg) => appArg.id === appIdArg);
+    }
+    async fetchJson(pathArg) {
+        const url = `${this.baseUrl}/${pathArg}`;
+        const response = await this.fetchRef(url);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} for ${url}`);
+        }
+        return response.json();
+    }
+    async fetchTextFromUrl(urlArg) {
+        const response = await this.fetchRef(urlArg);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} for ${urlArg}`);
+        }
+        return response.text();
+    }
+    async fetchDockerManifestDigest(imageArg) {
+        const manifestUrl = `https://${imageArg.registry}/v2/${imageArg.repository}/manifests/${imageArg.tag}`;
+        const headers = new Headers({
+            Accept: [
+                'application/vnd.docker.distribution.manifest.v2+json',
+                'application/vnd.oci.image.manifest.v1+json',
+                'application/vnd.docker.distribution.manifest.list.v2+json',
+                'application/vnd.oci.image.index.v1+json',
+            ].join(', '),
+        });
+        let response = await this.fetchRef(manifestUrl, { method: 'HEAD', headers });
+        if (response.status === 401) {
+            const authHeader = response.headers.get('www-authenticate');
+            const token = authHeader ? await this.fetchDockerRegistryToken(authHeader, imageArg.repository) : null;
+            if (token) {
+                headers.set('Authorization', `Bearer ${token}`);
+                response = await this.fetchRef(manifestUrl, { method: 'HEAD', headers });
+            }
+        }
+        if (!response.ok || !response.headers.get('docker-content-digest')) {
+            response = await this.fetchRef(manifestUrl, { method: 'GET', headers });
+        }
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} while resolving ${imageArg.repository}:${imageArg.tag}`);
+        }
+        return response.headers.get('docker-content-digest');
+    }
+    async fetchDockerRegistryToken(authHeaderArg, repositoryArg) {
+        const match = authHeaderArg.match(/^Bearer\s+(.+)$/i);
+        if (!match)
+            return null;
+        const authParams = new Map();
+        for (const partArg of match[1].match(/(?:[^,\"]+|\"[^\"]*\")+/g) || []) {
+            const [key, rawValue] = partArg.split('=');
+            if (!key || rawValue === undefined)
+                continue;
+            authParams.set(key.trim(), rawValue.trim().replace(/^\"|\"$/g, ''));
+        }
+        const realm = authParams.get('realm');
+        if (!realm)
+            return null;
+        const tokenUrl = new URL(realm);
+        const service = authParams.get('service');
+        const scope = authParams.get('scope') || `repository:${repositoryArg}:pull`;
+        if (service)
+            tokenUrl.searchParams.set('service', service);
+        tokenUrl.searchParams.set('scope', scope);
+        const response = await this.fetchRef(tokenUrl.toString());
+        if (!response.ok)
+            return null;
+        const tokenResponse = await response.json();
+        return tokenResponse.token || tokenResponse.access_token || null;
+    }
+    validateVolume(volumeArg, labelArg) {
+        if (!volumeArg.mountPath || !volumeArg.mountPath.startsWith('/')) {
+            throw new Error(`Invalid ${labelArg}: mountPath must be an absolute path`);
+        }
+        if (volumeArg.mountPath.includes(':')) {
+            throw new Error(`Invalid ${labelArg}: mountPath must not contain ':'`);
+        }
+        if ((volumeArg.source || volumeArg.name)?.includes(':')) {
+            throw new Error(`Invalid ${labelArg}: source/name must not contain ':'`);
+        }
+    }
+    validatePublishedPorts(publishedPortsArg = [], labelArg) {
+        const seenPublishedPorts = new Set();
+        for (const portArg of publishedPortsArg) {
+            const protocol = portArg.protocol || 'tcp';
+            const targetStart = portArg.targetPort;
+            const targetEnd = portArg.targetPortEnd || targetStart;
+            const publishedStart = portArg.publishedPort || targetStart;
+            const publishedEnd = portArg.publishedPortEnd || (publishedStart + (targetEnd - targetStart));
+            const hostIp = portArg.hostIp || '0.0.0.0';
+            if (!['tcp', 'udp'].includes(protocol)) {
+                throw new Error(`Invalid ${labelArg}: published port protocol '${protocol}' is not supported`);
+            }
+            this.assertValidPort(targetStart, `${labelArg} targetPort`);
+            this.assertValidPort(targetEnd, `${labelArg} targetPortEnd`);
+            this.assertValidPort(publishedStart, `${labelArg} publishedPort`);
+            this.assertValidPort(publishedEnd, `${labelArg} publishedPortEnd`);
+            if (targetEnd < targetStart || publishedEnd < publishedStart) {
+                throw new Error(`Invalid ${labelArg}: published port ranges must be ascending`);
+            }
+            if ((targetEnd - targetStart) !== (publishedEnd - publishedStart)) {
+                throw new Error(`Invalid ${labelArg}: target and published port ranges must have the same size`);
+            }
+            if ((targetEnd - targetStart) > 1000) {
+                throw new Error(`Invalid ${labelArg}: published port ranges may not exceed 1001 ports`);
+            }
+            for (let offset = 0; offset <= targetEnd - targetStart; offset++) {
+                const publishedPort = publishedStart + offset;
+                const publishedKey = `${hostIp}/${protocol}/${publishedPort}`;
+                const wildcardKey = `0.0.0.0/${protocol}/${publishedPort}`;
+                const conflictsWithWildcard = hostIp === '0.0.0.0'
+                    ? Array.from(seenPublishedPorts).some((keyArg) => keyArg.endsWith(`/${protocol}/${publishedPort}`))
+                    : seenPublishedPorts.has(wildcardKey);
+                if (seenPublishedPorts.has(publishedKey) || conflictsWithWildcard) {
+                    throw new Error(`Invalid ${labelArg}: duplicate published port ${hostIp}:${publishedPort}/${protocol}`);
+                }
+                seenPublishedPorts.add(publishedKey);
+            }
+        }
+    }
+    assertValidPort(portArg, labelArg) {
+        if (!Number.isInteger(portArg) || portArg < 1 || portArg > 65535) {
+            throw new Error(`Invalid ${labelArg}: ${portArg}. Expected an integer port between 1 and 65535.`);
+        }
+    }
+}
+export function parseAppStoreIndex(inputArg) {
+    const appStore = inputArg;
+    if (!appStore || typeof appStore !== 'object' || !Array.isArray(appStore.apps)) {
+        throw new Error('Invalid appstore format');
+    }
+    return appStore;
+}
+export function parseServezoneAppStoreManifest(inputArg) {
+    const manifest = inputArg;
+    if (!manifest || typeof manifest !== 'object') {
+        throw new Error('Appstore manifest must be an object');
+    }
+    if (manifest.schemaVersion !== 1) {
+        throw new Error(`Unsupported appstore manifest schemaVersion '${manifest.schemaVersion}'`);
+    }
+    if (!manifest.app?.id || !manifest.app?.name) {
+        throw new Error('Appstore manifest app.id and app.name are required');
+    }
+    return manifest;
+}
+export function parseDockerImageReference(imageArg) {
+    const [imageWithoutDigest, digest] = imageArg.split('@');
+    const imageParts = imageWithoutDigest.split('/');
+    const firstPart = imageParts[0];
+    const hasExplicitRegistry = imageParts.length > 1
+        && (firstPart.includes('.') || firstPart.includes(':') || firstPart === 'localhost');
+    const registry = hasExplicitRegistry ? firstPart : 'registry-1.docker.io';
+    const repositoryParts = hasExplicitRegistry ? imageParts.slice(1) : imageParts;
+    let repositoryWithTag = repositoryParts.join('/');
+    if (!repositoryWithTag) {
+        throw new Error(`Invalid Docker image reference '${imageArg}'`);
+    }
+    if (!hasExplicitRegistry && !repositoryWithTag.includes('/')) {
+        repositoryWithTag = `library/${repositoryWithTag}`;
+    }
+    const lastSlashIndex = repositoryWithTag.lastIndexOf('/');
+    const lastColonIndex = repositoryWithTag.lastIndexOf(':');
+    const hasTag = lastColonIndex > lastSlashIndex;
+    const repository = hasTag ? repositoryWithTag.slice(0, lastColonIndex) : repositoryWithTag;
+    const tag = hasTag ? repositoryWithTag.slice(lastColonIndex + 1) : 'latest';
+    return { registry, repository, tag, digest };
+}
+export function createAppStoreVersionForDockerSource(sourceArg, fallbackVersionArg, digestArg) {
+    if (sourceArg.tracking !== 'digest' || !digestArg) {
+        return fallbackVersionArg;
+    }
+    const parsedImage = parseDockerImageReference(sourceArg.image);
+    return `${parsedImage.tag}@${digestArg}`;
+}
+async function createSha256Hex(inputArg) {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(inputArg));
+    return Array.from(new Uint8Array(digest))
+        .map((byteArg) => byteArg.toString(16).padStart(2, '0'))
+        .join('');
+}
+function uniqueStrings(valuesArg) {
+    return Array.from(new Set(valuesArg.filter(Boolean)));
+}
+function withoutUndefined(objectArg) {
+    return Object.fromEntries(Object.entries(objectArg).filter(([, valueArg]) => valueArg !== undefined));
+}
+function getUpgradeStrategyForConfig(configArg) {
+    if (configArg?.upgradeStrategy)
+        return configArg.upgradeStrategy;
+    if (configArg?.source?.type === 'dockerImage' && configArg.source.tracking === 'digest')
+        return 'dockerDigest';
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.appstoreresolver.js","sourceRoot":"","sources":["../ts_client/classes.appstoreresolver.ts"],"names":[],"mappings":"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"}

package/dist_ts_client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classes.appstoreresolver.js';
+export * from './types.js';

package/dist_ts_client/index.js

@@ -0,0 +1,3 @@
+export * from './classes.appstoreresolver.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLFlBQVksQ0FBQyJ9

package/dist_ts_client/types.d.ts

@@ -0,0 +1,27 @@
+import type * as interfaces from '@serve.zone/interfaces';
+export type TAppStoreFetch = typeof fetch;
+export type TAppStoreIndex = interfaces.appstore.IAppStoreIndex;
+export type TAppStoreApp = interfaces.appstore.IAppStoreApp;
+export type TAppStoreAppMeta = interfaces.appstore.IAppStoreAppMeta;
+export type TAppStoreVersionConfig = interfaces.appstore.IAppStoreVersionConfig;
+export type TAppStoreDockerImageSource = interfaces.appstore.IAppStoreDockerImageSource;
+export type TAppStoreRepoManifestSource = interfaces.appstore.IAppStoreRepoManifestSource;
+export type TAppStoreResolvedSource = interfaces.appstore.IAppStoreResolvedSource;
+export type TServezoneAppStoreManifest = interfaces.appstore.IServezoneAppStoreManifest;
+export interface IAppStoreResolverOptions {
+    baseUrl?: string;
+    fetch?: TAppStoreFetch;
+    resolveDockerDigests?: boolean;
+    now?: () => Date;
+}
+export interface IResolvedAppStoreApp {
+    appStoreApp: TAppStoreApp;
+    appMeta: TAppStoreAppMeta;
+    configsByVersion: Map<string, TAppStoreVersionConfig>;
+}
+export interface IParsedDockerImageReference {
+    registry: string;
+    repository: string;
+    tag: string;
+    digest?: string;
+}

package/dist_ts_client/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19jbGllbnQvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Task Venture Capital GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.