@zeroheight/adoption-cli 3.0.2 → 3.1.1-rc.0

package/dist/common/api.js

@@ -1,174 +0,0 @@
-import { IncorrectScopeError, MaxRetriesError, UnauthorizedError, UnknownError, } from "./errors.js";
-import logger from "./logging.js";
-const API_PATH = "/open_api/v2";
-export var ResponseStatus;
-(function (ResponseStatus) {
-    ResponseStatus["Success"] = "success";
-    ResponseStatus["Error"] = "error";
-    ResponseStatus["Fail"] = "fail";
-})(ResponseStatus || (ResponseStatus = {}));
-export function getZeroheightURL() {
-    if (process.env["NODE_ENV"] === "dev") {
-        return new URL("https://zeroheight.dev");
-    }
-    else {
-        return new URL("https://zeroheight.com");
-    }
-}
-export async function submitPackageDetails(name, path, version, aliases, credentials) {
-    return post("/design_system_packages", {
-        name,
-        path,
-        latest_version: version,
-        aliases,
-    }, credentials);
-}
-export async function submitMonitoredRepoDetails(name, version, lockfilePath, packages, credentials) {
-    return post("/monitored_repositories", {
-        name,
-        lock_file_path: lockfilePath,
-        packages,
-        version,
-    }, credentials);
-}
-export async function submitComponentUsageData(usage, repoName, credentials) {
-    return post("/component_usages", {
-        repo_name: repoName,
-        usage: transformUsageByName(usage),
-    }, credentials);
-}
-export async function submitTokenLiteralUsageData(usage, repoName, credentials) {
-    return post("/token_literal_usages", {
-        token_literal_usage: {
-            repo_name: repoName,
-            usage: transformTokenLiteralUsageByName(usage),
-        },
-    }, credentials);
-}
-export async function getExistingRepoNames(credentials) {
-    return get("/component_usages/repo_names", credentials);
-}
-export async function getAuthDetails(credentials) {
-    return get("/auth_tokens", credentials);
-}
-async function get(path, credentials) {
-    return request(path, credentials, {
-        method: "GET",
-    });
-}
-async function post(path, body, credentials) {
-    return request(path, credentials, {
-        method: "POST",
-        body: JSON.stringify(body),
-    });
-}
-async function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function request(path, credentials, init) {
-    const url = getZeroheightURL();
-    url.pathname = API_PATH + path;
-    if (process.env["NODE_ENV"] === "dev") {
-        process.env["NODE_TLS_REJECT_UNAUTHORIZED"] = "0";
-    }
-    const maxRetries = 3;
-    let retries = 0;
-    while (retries < maxRetries) {
-        logger.info({ request: { url: url.toString(), init, retries } }, "Making API request");
-        const response = await fetch(url, {
-            ...init,
-            headers: {
-                "X-API-CLIENT-NAME": "cli",
-                "X-API-CLIENT": credentials.client,
-                "X-API-KEY": credentials.token,
-                "Content-Type": "application/json",
-            },
-        });
-        if (response.status === 401) {
-            logger.error({ response: { status: response.status, body: await response.text() } }, "Unauthorized response from API");
-            throw new UnauthorizedError();
-        }
-        else if (response.status === 429) {
-            retries++;
-            const responseData = await response.json();
-            const waitTime = responseData.data.reset_time * 1000 - Date.now();
-            logger.info(`Rate limited, waiting for ${waitTime}ms`);
-            await sleep(waitTime);
-            continue;
-        }
-        else if (response.status < 200 || response.status >= 300) {
-            logger.error({ response: { status: response.status, body: await response.text() } }, "API request failed");
-            if (response.status === 403) {
-                throw new IncorrectScopeError();
-            }
-            else {
-                throw new UnknownError();
-            }
-        }
-        const responseJson = await response.json();
-        logger.info({ response: { status: response.status, body: responseJson } }, "API response");
-        return responseJson;
-    }
-    throw new MaxRetriesError();
-}
-export function mergeUsageProps(newProps, currentProps) {
-    if (!currentProps)
-        return newProps;
-    if (!newProps)
-        return currentProps;
-    const props = Array.from(new Set([...Object.keys(currentProps), ...Object.keys(newProps)]));
-    const mergedProps = {};
-    props.forEach((prop) => {
-        const existingProp = currentProps[prop] ?? {};
-        const newProp = newProps[prop];
-        const mergedValues = [
-            ...(existingProp?.values ?? []),
-            ...(newProp?.values ?? []),
-        ];
-        mergedProps[prop] = {
-            type: Array.from(new Set([...(existingProp.type ?? []), ...(newProp?.type ?? [])])),
-            count: mergedValues.length,
-            values: mergedValues,
-        };
-    });
-    return mergedProps;
-}
-/**
- * Transform usage map grouped by file into usage map grouped by component
- */
-function transformUsageByName(usage) {
-    const transformedUsageMap = new Map();
-    for (const [file, rawUsage] of usage) {
-        for (const { count, package: packageName, name, props } of rawUsage) {
-            const key = `package:${packageName} name:${name}`;
-            const currentValue = transformedUsageMap.get(key);
-            const newFileList = [...(currentValue?.files ?? []), file]; // Add file to list
-            transformedUsageMap.set(key, {
-                name: currentValue?.name ?? name,
-                files: Array.from(new Set(newFileList)), // Ensure unique file paths
-                count: count + (currentValue?.count ?? 0),
-                package: packageName,
-                props: mergeUsageProps(props, currentValue?.props ?? {}),
-            });
-        }
-    }
-    return Array.from(transformedUsageMap.values());
-}
-function transformTokenLiteralUsageByName(usage) {
-    const transformedUsageMap = new Map();
-    for (const [file, { hex, rgb, hsla }] of usage) {
-        // These values shouldn't collide as they're all different notations and types
-        const values = [...hex, ...rgb, ...hsla];
-        for (const colorValue of values) {
-            const currentValue = transformedUsageMap.get(colorValue);
-            const newFileList = [...(currentValue?.files ?? []), file];
-            transformedUsageMap.set(colorValue, {
-                value: colorValue,
-                type: "color",
-                files: newFileList,
-                count: (currentValue?.count ?? 0) + 1,
-            });
-        }
-    }
-    return Array.from(transformedUsageMap.values());
-}

package/dist/common/config.d.ts

@@ -1,14 +0,0 @@
-export interface Credentials {
-    token: string;
-    client: string;
-}
-export interface Config extends Credentials {
-    repoNames: Record<string, string>;
-}
-export declare function configPath(): string;
-/**
- * Read the credentials from the user's home directory
- * @returns access token and client id or null
- */
-export declare function readConfig(): Promise<Config | null>;
-export declare function writeConfig(newValues: Partial<Config>): Promise<void>;

package/dist/common/config.js

@@ -1,41 +0,0 @@
-import { readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
-import path from "path";
-export function configPath() {
-    return path.join(homedir(), ".zeroheight-config.json");
-}
-/**
- * Read the credentials from the user's home directory
- * @returns access token and client id or null
- */
-export async function readConfig() {
-    try {
-        const rawData = await readFile(configPath(), "utf8");
-        const { token, client, repoNames = {} } = JSON.parse(rawData);
-        return { token, client, repoNames };
-    }
-    catch (e) {
-        const client = process.env["ZEROHEIGHT_CLIENT_ID"];
-        const token = process.env["ZEROHEIGHT_ACCESS_TOKEN"];
-        if (client && token) {
-            return { token, client, repoNames: {} };
-        }
-        return null;
-    }
-}
-export async function writeConfig(newValues) {
-    const config = (await readConfig()) ??
-        {
-            repoNames: {},
-        };
-    // TODO: if we have a more complex config, we should use a deep merge here
-    const payload = JSON.stringify({
-        ...config,
-        ...newValues,
-        repoNames: {
-            ...config.repoNames,
-            ...(newValues.repoNames ?? {}),
-        },
-    });
-    return writeFile(configPath(), payload);
-}

package/dist/common/errors.d.ts

@@ -1,15 +0,0 @@
-export declare class ApiError extends Error {
-    constructor(message: string);
-}
-export declare class UnauthorizedError extends ApiError {
-    constructor();
-}
-export declare class IncorrectScopeError extends ApiError {
-    constructor();
-}
-export declare class UnknownError extends ApiError {
-    constructor();
-}
-export declare class MaxRetriesError extends ApiError {
-    constructor();
-}

package/dist/common/errors.js

@@ -1,26 +0,0 @@
-export class ApiError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ApiError";
-    }
-}
-export class UnauthorizedError extends ApiError {
-    constructor() {
-        super("Unauthorized. Please reset your authentication by running: npx @zeroheight/adoption-cli auth");
-    }
-}
-export class IncorrectScopeError extends ApiError {
-    constructor() {
-        super("The authentication token used does not have the correct scope. \n\nPlease create a new authentication token with the 'Adoption' scopes and then reset your authentication by running: npx @zeroheight/adoption-cli auth");
-    }
-}
-export class UnknownError extends ApiError {
-    constructor() {
-        super("An unknown error occurred while calling the zeroheight API");
-    }
-}
-export class MaxRetriesError extends ApiError {
-    constructor() {
-        super("Max retries exceeded while calling the zeroheight API");
-    }
-}

package/dist/common/logging.d.ts

@@ -1,4 +0,0 @@
-declare const logger: import("pino").Logger<never, boolean>;
-export declare function setFileStream(path: string): void;
-export declare function setStdErrStream(): void;
-export default logger;

package/dist/common/logging.js

@@ -1,26 +0,0 @@
-import { pino } from "pino";
-import { createWriteStream } from "fs";
-import pretty from "pino-pretty";
-const streams = [];
-const loggerOptions = {
-    base: null,
-    level: "warn",
-    timestamp: pino.stdTimeFunctions.isoTime,
-    formatters: {
-        level: (label) => {
-            return { level: label.toUpperCase() };
-        },
-    },
-};
-const multistream = pino.multistream(streams);
-const logger = pino(loggerOptions, multistream);
-export function setFileStream(path) {
-    multistream.add({ stream: createWriteStream(path, { flags: "a" }) });
-}
-export function setStdErrStream() {
-    multistream.add({
-        stream: pretty({ destination: process.stderr, ignore: "pid,hostname" }),
-        level: "error",
-    });
-}
-export default logger;

package/dist/common/types/package-file.d.ts

@@ -1,13 +0,0 @@
-/**
- * Sparse package.json interface, only containing properties we care about
- */
-export interface PackageFile {
-    name: string;
-    path: string;
-    version: string;
-    exports?: Record<string, Partial<{
-        import: string;
-        require: string;
-        types: string;
-    }> | string>;
-}

package/dist/common/types/package-file.js

@@ -1 +0,0 @@
-export {};

package/dist/components/analyze/analyze.d.ts

@@ -1,14 +0,0 @@
-import React from "react";
-import { RawColorUsageMap, RawComponentUsageMap } from "../../commands/analyze.js";
-export interface AnalyzeProps {
-    onAnalyzeFiles: () => Promise<{
-        errorFile: string | null;
-        usage: RawComponentUsageMap;
-    }>;
-    onAnalyzeColorUsage: () => Promise<{
-        errorFile: string | null;
-        usage: RawColorUsageMap;
-    }>;
-    repoName?: string;
-}
-export default function Analyze({ onAnalyzeFiles, onAnalyzeColorUsage, repoName, }: AnalyzeProps): React.JSX.Element;