@redocly/cli 0.0.0-snapshot.1737554067

package/lib/types.d.ts

@@ -0,0 +1,43 @@
+import type { BundleOutputFormat, Region, Config, RuleSeverity } from '@redocly/openapi-core';
+import type { ArgumentsCamelCase } from 'yargs';
+import type { LintOptions } from './commands/lint';
+import type { BundleOptions } from './commands/bundle';
+import type { JoinOptions } from './commands/join';
+import type { LoginOptions } from './commands/login';
+import type { PushOptions } from './commands/push';
+import type { StatsOptions } from './commands/stats';
+import type { SplitOptions } from './commands/split';
+import type { PreviewDocsOptions } from './commands/preview-docs';
+import type { BuildDocsArgv } from './commands/build-docs/types';
+import type { PushOptions as CMSPushOptions } from './cms/commands/push';
+import type { PushStatusOptions } from './cms/commands/push-status';
+import type { PreviewProjectOptions } from './commands/preview-project/types';
+import type { TranslationsOptions } from './commands/translations';
+import type { EjectOptions } from './commands/eject';
+export type Totals = {
+    errors: number;
+    warnings: number;
+    ignored: number;
+};
+export type Entrypoint = {
+    path: string;
+    alias?: string;
+    output?: string;
+};
+export declare const outputExtensions: ReadonlyArray<BundleOutputFormat>;
+export type OutputExtensions = 'json' | 'yaml' | 'yml' | undefined;
+export declare const regionChoices: ReadonlyArray<Region>;
+export type CommandOptions = StatsOptions | SplitOptions | JoinOptions | PushOptions | CMSPushOptions | LintOptions | BundleOptions | LoginOptions | PreviewDocsOptions | BuildDocsArgv | PushStatusOptions | PreviewProjectOptions | TranslationsOptions | EjectOptions;
+export type VerifyConfigOptions = {
+    config?: string;
+    'lint-config'?: RuleSeverity;
+};
+export type Skips = {
+    'skip-rule'?: string[];
+    'skip-decorator'?: string[];
+    'skip-preprocessor'?: string[];
+};
+export type ConfigApis = Pick<Config, 'apis' | 'configFile'>;
+export type PushArguments = ArgumentsCamelCase<PushOptions & CMSPushOptions & {
+    apis: string[];
+}>;

package/lib/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regionChoices = exports.outputExtensions = void 0;
+exports.outputExtensions = ['json', 'yaml', 'yml'];
+exports.regionChoices = ['us', 'eu'];

package/lib/utils/__mocks__/miscellaneous.d.ts

@@ -0,0 +1,43 @@
+export declare const getFallbackApisOrExit: jest.Mock<any, [entrypoints: any]>;
+export declare const dumpBundle: jest.Mock<string, []>;
+export declare const slash: jest.Mock<any, any>;
+export declare const pluralize: jest.Mock<any, any>;
+export declare const getExecutionTime: jest.Mock<any, any>;
+export declare const printExecutionTime: jest.Mock<any, any>;
+export declare const printUnusedWarnings: jest.Mock<any, any>;
+export declare const printLintTotals: jest.Mock<any, any>;
+export declare const getOutputFileName: jest.Mock<{
+    outputFile: string;
+    ext: string;
+}, []>;
+export declare const handleError: jest.Mock<any, any>;
+export declare const exitWithError: jest.Mock<any, any>;
+export declare const writeYaml: jest.Mock<any, any>;
+export declare const loadConfigAndHandleErrors: jest.Mock<{
+    configFile: null;
+    styleguide: {
+        addIgnore: jest.Mock<any, any>;
+        skipRules: jest.Mock<any, any>;
+        skipPreprocessors: jest.Mock<any, any>;
+        saveIgnore: jest.Mock<any, any>;
+        skipDecorators: jest.Mock<any, any>;
+        ignore: null;
+        decorators: {
+            oas2: {};
+            oas3_0: {};
+            oas3_1: {};
+        };
+        preprocessors: {
+            oas2: {};
+            oas3_0: {};
+            oas3_1: {};
+        };
+    };
+}, []>;
+export declare const checkIfRulesetExist: jest.Mock<any, any>;
+export declare const sortTopLevelKeysForOas: jest.Mock<any, [document: any]>;
+export declare const getAndValidateFileExtension: jest.Mock<string | undefined, [fileName: string]>;
+export declare const writeToFileByExtension: jest.Mock<any, any>;
+export declare const checkForDeprecatedOptions: jest.Mock<any, any>;
+export declare const saveBundle: jest.Mock<any, any>;
+export declare const formatPath: jest.Mock<string, [path: string]>;

package/lib/utils/__mocks__/miscellaneous.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPath = exports.saveBundle = exports.checkForDeprecatedOptions = exports.writeToFileByExtension = exports.getAndValidateFileExtension = exports.sortTopLevelKeysForOas = exports.checkIfRulesetExist = exports.loadConfigAndHandleErrors = exports.writeYaml = exports.exitWithError = exports.handleError = exports.getOutputFileName = exports.printLintTotals = exports.printUnusedWarnings = exports.printExecutionTime = exports.getExecutionTime = exports.pluralize = exports.slash = exports.dumpBundle = exports.getFallbackApisOrExit = void 0;
+const config_1 = require("../../__tests__/fixtures/config");
+exports.getFallbackApisOrExit = jest.fn((entrypoints) => entrypoints.map((path) => ({ path })));
+exports.dumpBundle = jest.fn(() => '');
+exports.slash = jest.fn();
+exports.pluralize = jest.fn();
+exports.getExecutionTime = jest.fn();
+exports.printExecutionTime = jest.fn();
+exports.printUnusedWarnings = jest.fn();
+exports.printLintTotals = jest.fn();
+exports.getOutputFileName = jest.fn(() => ({ outputFile: 'test.yaml', ext: 'yaml' }));
+exports.handleError = jest.fn();
+exports.exitWithError = jest.fn();
+exports.writeYaml = jest.fn();
+exports.loadConfigAndHandleErrors = jest.fn(() => config_1.ConfigFixture);
+exports.checkIfRulesetExist = jest.fn();
+exports.sortTopLevelKeysForOas = jest.fn((document) => document);
+exports.getAndValidateFileExtension = jest.fn((fileName) => fileName.split('.').pop());
+exports.writeToFileByExtension = jest.fn();
+exports.checkForDeprecatedOptions = jest.fn();
+exports.saveBundle = jest.fn();
+exports.formatPath = jest.fn((path) => path);

package/lib/utils/assert-node-version.d.ts

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

package/lib/utils/assert-node-version.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver = require("semver");
+const path = require("path");
+const process = require("process");
+const colorette_1 = require("colorette");
+try {
+    const { engines } = require(path.join(__dirname, '../package.json'));
+    const version = engines.node;
+    if (!semver.satisfies(process.version, version)) {
+        process.stderr.write((0, colorette_1.yellow)(`\n⚠️ Warning: failed to satisfy expected node version. Expected: "${version}", Current "${process.version}"\n\n`));
+    }
+}
+catch (e) {
+    // Do nothing
+}

package/lib/utils/fetch-with-timeout.d.ts

@@ -0,0 +1,7 @@
+import { type RequestInit } from 'node-fetch';
+export declare const DEFAULT_FETCH_TIMEOUT = 3000;
+export type FetchWithTimeoutOptions = RequestInit & {
+    timeout?: number;
+};
+declare const _default: (url: string, { timeout, ...options }?: FetchWithTimeoutOptions) => Promise<import("node-fetch").Response>;
+export default _default;

package/lib/utils/fetch-with-timeout.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FETCH_TIMEOUT = void 0;
+const node_fetch_1 = require("node-fetch");
+const abort_controller_1 = require("abort-controller");
+const openapi_core_1 = require("@redocly/openapi-core");
+exports.DEFAULT_FETCH_TIMEOUT = 3000;
+exports.default = async (url, { timeout, ...options } = {}) => {
+    if (!timeout) {
+        return (0, node_fetch_1.default)(url, {
+            ...options,
+            agent: (0, openapi_core_1.getProxyAgent)(),
+        });
+    }
+    const controller = new abort_controller_1.default();
+    const timeoutId = setTimeout(() => {
+        controller.abort();
+    }, timeout);
+    const res = await (0, node_fetch_1.default)(url, {
+        signal: controller.signal,
+        ...options,
+        agent: (0, openapi_core_1.getProxyAgent)(),
+    });
+    clearTimeout(timeoutId);
+    return res;
+};

package/lib/utils/getCommandNameFromArgs.d.ts

@@ -0,0 +1,2 @@
+import type { Arguments } from 'yargs';
+export declare function getCommandNameFromArgs(argv: Arguments | undefined): string | number;

package/lib/utils/getCommandNameFromArgs.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandNameFromArgs = getCommandNameFromArgs;
+function getCommandNameFromArgs(argv) {
+    return argv?._?.[0] ?? '';
+}

package/lib/utils/js-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isEmptyObject(obj: any): boolean;
+export declare function isString(str: string): boolean;
+export declare function keysOf<T>(obj: T): (keyof T)[];
+export declare function capitalize(s: string): string;

package/lib/utils/js-utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.isEmptyObject = isEmptyObject;
+exports.isString = isString;
+exports.keysOf = keysOf;
+exports.capitalize = capitalize;
+function isObject(obj) {
+    const type = typeof obj;
+    return type === 'function' || (type === 'object' && !!obj);
+}
+function isEmptyObject(obj) {
+    return !!obj && Object.keys(obj).length === 0;
+}
+function isString(str) {
+    return Object.prototype.toString.call(str) === '[object String]';
+}
+function keysOf(obj) {
+    if (!obj)
+        return [];
+    return Object.keys(obj);
+}
+function capitalize(s) {
+    if (s?.length > 0) {
+        return s[0].toUpperCase() + s.slice(1);
+    }
+    return s;
+}

package/lib/utils/miscellaneous.d.ts

@@ -0,0 +1,81 @@
+import type { Arguments } from 'yargs';
+import type { BundleOutputFormat, StyleguideConfig, Region, Config, Oas3Definition, Oas2Definition } from '@redocly/openapi-core';
+import type { RawConfigProcessor } from '@redocly/openapi-core/lib/config';
+import type { Totals, Entrypoint, ConfigApis, CommandOptions, OutputExtensions } from '../types';
+export declare function getFallbackApisOrExit(argsApis: string[] | undefined, config: ConfigApis): Promise<Entrypoint[]>;
+export declare function getExecutionTime(startedAt: number): string;
+export declare function printExecutionTime(commandName: string, startedAt: number, api: string): void;
+export declare function pathToFilename(path: string, pathSeparator: string): string;
+export declare function escapeLanguageName(lang: string): string;
+export declare function langToExt(lang: string): any;
+export declare class CircularJSONNotSupportedError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}
+export declare function dumpBundle(obj: any, format: BundleOutputFormat, dereference?: boolean): string;
+export declare function saveBundle(filename: string, output: string): void;
+export declare function promptUser(query: string, hideUserInput?: boolean): Promise<string>;
+export declare function readYaml(filename: string): unknown;
+export declare function writeToFileByExtension(data: unknown, filePath: string, noRefs?: boolean): void;
+export declare function writeYaml(data: any, filename: string, noRefs?: boolean): void;
+export declare function writeJson(data: unknown, filename: string): void;
+export declare function getAndValidateFileExtension(fileName: string): NonNullable<OutputExtensions>;
+export declare function handleError(e: Error, ref: string): void;
+export declare class HandledError extends Error {
+}
+export declare function printLintTotals(totals: Totals, definitionsCount: number): void;
+export declare function printConfigLintTotals(totals: Totals, command?: string | number): void;
+export declare function getOutputFileName({ entrypoint, output, argvOutput, ext, entries, }: {
+    entrypoint: string;
+    output?: string;
+    argvOutput?: string;
+    ext?: BundleOutputFormat;
+    entries: number;
+}): {
+    ext: BundleOutputFormat;
+    outputFile?: undefined;
+} | {
+    outputFile: string;
+    ext: BundleOutputFormat;
+};
+export declare function printUnusedWarnings(config: StyleguideConfig): void;
+export declare function exitWithError(message: string): void;
+/**
+ * Checks if dir is subdir of parent
+ */
+export declare function isSubdir(parent: string, dir: string): boolean;
+export declare function loadConfigAndHandleErrors(options?: {
+    configPath?: string;
+    customExtends?: string[];
+    processRawConfig?: RawConfigProcessor;
+    files?: string[];
+    region?: Region;
+}): Promise<Config | void>;
+export declare function sortTopLevelKeysForOas(document: Oas3Definition | Oas2Definition): Oas3Definition | Oas2Definition;
+export declare function checkIfRulesetExist(rules: typeof StyleguideConfig.prototype.rules): void;
+export declare function cleanColors(input: string): string;
+export declare function sendTelemetry(argv: Arguments | undefined, exit_code: ExitCode, has_config: boolean | undefined, spec_version: string | undefined, spec_keyword: string | undefined, spec_full_version: string | undefined): Promise<void>;
+export type ExitCode = 0 | 1 | 2;
+export type Analytics = {
+    event: string;
+    event_time: string;
+    logged_in: boolean;
+    command: string | number;
+    arguments: Record<string, unknown>;
+    node_version: string;
+    npm_version: string;
+    version: string;
+    exit_code: ExitCode;
+    environment?: string;
+    environment_ci?: string;
+    raw_input: string;
+    has_config?: boolean;
+    spec_version?: string;
+    spec_keyword?: string;
+    spec_full_version?: string;
+};
+export declare function cleanArgs(args: CommandOptions): Record<string, unknown>;
+export declare function cleanRawInput(argv: string[]): string;
+export declare function checkForDeprecatedOptions<T>(argv: T, deprecatedOptions: Array<keyof T>): void;
+export declare function notifyAboutIncompatibleConfigOptions(themeOpenapiOptions: Record<string, unknown> | undefined): void;
+export declare function formatPath(path: string): string;