@redocly/openapi-core 1.34.3 → 2.0.0-next.0

package/src/lint.ts

@@ -1,190 +0,0 @@
-import { rootRedoclyConfigSchema } from '@redocly/config';
-import { BaseResolver, resolveDocument, makeDocumentFromString } from './resolve';
-import { normalizeVisitors } from './visitors';
-import { walkDocument } from './walk';
-import { initRules } from './config';
-import { normalizeTypes } from './types';
-import { releaseAjvInstance } from './rules/ajv';
-import { SpecVersion, getMajorSpecVersion, detectSpec, getTypes } from './oas-types';
-import { createConfigTypes } from './types/redocly-yaml';
-import { Struct } from './rules/common/struct';
-import { NoUnresolvedRefs } from './rules/no-unresolved-refs';
-
-import type { StyleguideConfig, Config } from './config';
-import type { Document, ResolvedRefMap } from './resolve';
-import type { ProblemSeverity, WalkContext } from './walk';
-import type { NodeType } from './types';
-import type {
-  Arazzo1Visitor,
-  Async2Visitor,
-  Async3Visitor,
-  NestedVisitObject,
-  Oas2Visitor,
-  Oas3Visitor,
-  Overlay1Visitor,
-  RuleInstanceConfig,
-} from './visitors';
-import type { CollectFn } from './utils';
-
-export async function lint(opts: {
-  ref: string;
-  config: Config;
-  externalRefResolver?: BaseResolver;
-  collectSpecData?: CollectFn;
-}) {
-  const { ref, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
-  const document = (await externalRefResolver.resolveDocument(null, ref, true)) as Document;
-  opts.collectSpecData?.(document.parsed);
-
-  return lintDocument({
-    document,
-    ...opts,
-    externalRefResolver,
-    config: opts.config.styleguide,
-  });
-}
-
-export async function lintFromString(opts: {
-  source: string;
-  absoluteRef?: string;
-  config: Config;
-  externalRefResolver?: BaseResolver;
-}) {
-  const { source, absoluteRef, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
-  const document = makeDocumentFromString(source, absoluteRef || '/');
-
-  return lintDocument({
-    document,
-    ...opts,
-    externalRefResolver,
-    config: opts.config.styleguide,
-  });
-}
-
-export async function lintDocument(opts: {
-  document: Document;
-  config: StyleguideConfig;
-  customTypes?: Record<string, NodeType>;
-  externalRefResolver: BaseResolver;
-}) {
-  releaseAjvInstance(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
-
-  const { document, customTypes, externalRefResolver, config } = opts;
-  const specVersion = detectSpec(document.parsed);
-  const specMajorVersion = getMajorSpecVersion(specVersion);
-  const rules = config.getRulesForSpecVersion(specMajorVersion);
-  const types = normalizeTypes(
-    config.extendTypes(customTypes ?? getTypes(specVersion), specVersion),
-    config
-  );
-
-  const ctx: WalkContext = {
-    problems: [],
-    oasVersion: specVersion,
-    visitorsData: {},
-  };
-
-  const preprocessors = initRules(rules, config, 'preprocessors', specVersion);
-  const regularRules = initRules(rules, config, 'rules', specVersion);
-
-  let resolvedRefMap = await resolveDocument({
-    rootDocument: document,
-    rootType: types.Root,
-    externalRefResolver,
-  });
-
-  if (preprocessors.length > 0) {
-    // Make additional pass to resolve refs defined in preprocessors.
-    walkDocument({
-      document,
-      rootType: types.Root,
-      normalizedVisitors: normalizeVisitors(preprocessors, types),
-      resolvedRefMap,
-      ctx,
-    });
-    resolvedRefMap = await resolveDocument({
-      rootDocument: document,
-      rootType: types.Root,
-      externalRefResolver,
-    });
-  }
-
-  const normalizedVisitors = normalizeVisitors(regularRules, types);
-
-  walkDocument({
-    document,
-    rootType: types.Root,
-    normalizedVisitors,
-    resolvedRefMap,
-    ctx,
-  });
-  return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
-}
-
-export async function lintConfig(opts: {
-  document: Document;
-  config: Config;
-  resolvedRefMap?: ResolvedRefMap;
-  severity?: ProblemSeverity;
-  externalRefResolver?: BaseResolver;
-  externalConfigTypes?: Record<string, NodeType>;
-}) {
-  const { document, severity, externalRefResolver = new BaseResolver(), config } = opts;
-
-  const ctx: WalkContext = {
-    problems: [],
-    oasVersion: SpecVersion.OAS3_0,
-    visitorsData: {},
-  };
-
-  const types = normalizeTypes(
-    opts.externalConfigTypes || createConfigTypes(rootRedoclyConfigSchema, config),
-    { doNotResolveExamples: config.styleguide.doNotResolveExamples }
-  );
-
-  const rules: (RuleInstanceConfig & {
-    visitor: NestedVisitObject<
-      unknown,
-      | Oas3Visitor
-      | Oas3Visitor[]
-      | Oas2Visitor
-      | Oas2Visitor[]
-      | Async2Visitor
-      | Async2Visitor[]
-      | Async3Visitor
-      | Async3Visitor[]
-      | Arazzo1Visitor
-      | Arazzo1Visitor[]
-      | Overlay1Visitor
-      | Overlay1Visitor[]
-    >;
-  })[] = [
-    {
-      severity: severity || 'error',
-      ruleId: 'configuration spec',
-      visitor: Struct({ severity: 'error' }),
-    },
-    {
-      severity: severity || 'error',
-      ruleId: 'configuration no-unresolved-refs',
-      visitor: NoUnresolvedRefs({ severity: 'error' }),
-    },
-  ];
-  const normalizedVisitors = normalizeVisitors(rules, types);
-  const resolvedRefMap =
-    opts.resolvedRefMap ||
-    (await resolveDocument({
-      rootDocument: document,
-      rootType: types.ConfigRoot,
-      externalRefResolver,
-    }));
-  walkDocument({
-    document,
-    rootType: types.ConfigRoot,
-    normalizedVisitors,
-    resolvedRefMap,
-    ctx,
-  });
-
-  return ctx.problems;
-}

package/src/logger.ts

@@ -1,36 +0,0 @@
-import * as colorette from 'colorette';
-import { isBrowser } from './env';
-import { identity } from './utils';
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore this works but some types are not working
-export const colorOptions = colorette.options;
-
-export const colorize = new Proxy(colorette, {
-  get(target: typeof colorette, prop: string): typeof identity {
-    if (isBrowser) {
-      return identity;
-    }
-
-    return (target as any)[prop];
-  },
-});
-class Logger {
-  protected stderr(str: string) {
-    return process.stderr.write(str);
-  }
-
-  info(str: string) {
-    return isBrowser ? console.log(str) : this.stderr(str);
-  }
-
-  warn(str: string) {
-    return isBrowser ? console.warn(str) : this.stderr(colorize.yellow(str));
-  }
-
-  error(str: string) {
-    return isBrowser ? console.error(str) : this.stderr(colorize.red(str));
-  }
-}
-
-export const logger = new Logger();

package/src/oas-types.ts

@@ -1,178 +0,0 @@
-import { Oas2Types } from './types/oas2';
-import { Oas3Types } from './types/oas3';
-import { Oas3_1Types } from './types/oas3_1';
-import { AsyncApi2Types } from './types/asyncapi2';
-import { AsyncApi3Types } from './types/asyncapi3';
-import { Arazzo1Types } from './types/arazzo';
-import { Overlay1Types } from './types/overlay';
-import { isPlainObject } from './utils';
-import { VERSION_PATTERN } from './typings/arazzo';
-
-import type {
-  BuiltInAsync2RuleId,
-  BuiltInAsync3RuleId,
-  BuiltInArazzo1RuleId,
-  BuiltInOAS2RuleId,
-  BuiltInOAS3RuleId,
-  BuiltInOverlay1RuleId,
-} from './types/redocly-yaml';
-import type {
-  Oas3Rule,
-  Oas3Preprocessor,
-  Oas2Rule,
-  Oas2Preprocessor,
-  Async2Preprocessor,
-  Async2Rule,
-  Async3Preprocessor,
-  Async3Rule,
-  Arazzo1Preprocessor,
-  Arazzo1Rule,
-  Overlay1Preprocessor,
-  Overlay1Rule,
-} from './visitors';
-
-export enum SpecVersion {
-  OAS2 = 'oas2',
-  OAS3_0 = 'oas3_0',
-  OAS3_1 = 'oas3_1',
-  Async2 = 'async2',
-  Async3 = 'async3',
-  Arazzo1 = 'arazzo1',
-  Overlay1 = 'overlay1',
-}
-
-export enum SpecMajorVersion {
-  OAS2 = 'oas2',
-  OAS3 = 'oas3',
-  Async2 = 'async2',
-  Async3 = 'async3',
-  Arazzo1 = 'arazzo1',
-  Overlay1 = 'overlay1',
-}
-
-const typesMap = {
-  [SpecVersion.OAS2]: Oas2Types,
-  [SpecVersion.OAS3_0]: Oas3Types,
-  [SpecVersion.OAS3_1]: Oas3_1Types,
-  [SpecVersion.Async2]: AsyncApi2Types,
-  [SpecVersion.Async3]: AsyncApi3Types,
-  [SpecVersion.Arazzo1]: Arazzo1Types,
-  [SpecVersion.Overlay1]: Overlay1Types,
-};
-
-export type RuleMap<Key extends string, RuleConfig, T> = Record<
-  T extends 'built-in' ? Key : string,
-  RuleConfig
->;
-export type Oas3RuleSet<T = undefined> = RuleMap<
-  BuiltInOAS3RuleId | 'struct' | 'assertions',
-  Oas3Rule,
-  T
->;
-export type Oas2RuleSet<T = undefined> = RuleMap<
-  BuiltInOAS2RuleId | 'struct' | 'assertions',
-  Oas2Rule,
-  T
->;
-export type Async2RuleSet<T = undefined> = RuleMap<
-  BuiltInAsync2RuleId | 'struct' | 'assertions',
-  Async2Rule,
-  T
->;
-export type Async3RuleSet<T = undefined> = RuleMap<
-  BuiltInAsync3RuleId | 'struct' | 'assertions',
-  Async3Rule,
-  T
->;
-export type Arazzo1RuleSet<T = undefined> = RuleMap<
-  BuiltInArazzo1RuleId | 'struct' | 'assertions',
-  Arazzo1Rule,
-  T
->;
-
-export type Overlay1RuleSet<T = undefined> = RuleMap<
-  BuiltInOverlay1RuleId | 'struct' | 'assertions',
-  Overlay1Rule,
-  T
->;
-export type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
-export type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
-export type Async2PreprocessorsSet = Record<string, Async2Preprocessor>;
-export type Async3PreprocessorsSet = Record<string, Async3Preprocessor>;
-export type Arazzo1PreprocessorsSet = Record<string, Arazzo1Preprocessor>;
-export type Overlay1PreprocessorsSet = Record<string, Overlay1Preprocessor>;
-
-export type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
-export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
-export type Async2DecoratorsSet = Record<string, Async2Preprocessor>;
-export type Async3DecoratorsSet = Record<string, Async3Preprocessor>;
-export type Arazzo1DecoratorsSet = Record<string, Arazzo1Preprocessor>;
-export type Overlay1DecoratorsSet = Record<string, Overlay1Preprocessor>;
-
-export function detectSpec(root: unknown): SpecVersion {
-  if (!isPlainObject(root)) {
-    throw new Error(`Document must be JSON object, got ${typeof root}`);
-  }
-
-  if (root.openapi && typeof root.openapi !== 'string') {
-    throw new Error(`Invalid OpenAPI version: should be a string but got "${typeof root.openapi}"`);
-  }
-
-  if (typeof root.openapi === 'string' && root.openapi.startsWith('3.0')) {
-    return SpecVersion.OAS3_0;
-  }
-
-  if (typeof root.openapi === 'string' && root.openapi.startsWith('3.1')) {
-    return SpecVersion.OAS3_1;
-  }
-
-  if (root.swagger && root.swagger === '2.0') {
-    return SpecVersion.OAS2;
-  }
-
-  if (root.openapi || root.swagger) {
-    throw new Error(`Unsupported OpenAPI version: ${root.openapi || root.swagger}`);
-  }
-
-  if (typeof root.asyncapi === 'string' && root.asyncapi.startsWith('2.')) {
-    return SpecVersion.Async2;
-  }
-
-  if (typeof root.asyncapi === 'string' && root.asyncapi.startsWith('3.')) {
-    return SpecVersion.Async3;
-  }
-
-  if (root.asyncapi) {
-    throw new Error(`Unsupported AsyncAPI version: ${root.asyncapi}`);
-  }
-
-  if (typeof root.arazzo === 'string' && VERSION_PATTERN.test(root.arazzo)) {
-    return SpecVersion.Arazzo1;
-  }
-
-  if (typeof root.overlay === 'string' && VERSION_PATTERN.test(root.overlay)) {
-    return SpecVersion.Overlay1;
-  }
-
-  throw new Error(`Unsupported specification`);
-}
-
-export function getMajorSpecVersion(version: SpecVersion): SpecMajorVersion {
-  if (version === SpecVersion.OAS2) {
-    return SpecMajorVersion.OAS2;
-  } else if (version === SpecVersion.Async2) {
-    return SpecMajorVersion.Async2;
-  } else if (version === SpecVersion.Async3) {
-    return SpecMajorVersion.Async3;
-  } else if (version === SpecVersion.Arazzo1) {
-    return SpecMajorVersion.Arazzo1;
-  } else if (version === SpecVersion.Overlay1) {
-    return SpecMajorVersion.Overlay1;
-  } else {
-    return SpecMajorVersion.OAS3;
-  }
-}
-
-export function getTypes(spec: SpecVersion) {
-  return typesMap[spec];
-}

package/src/output.ts

@@ -1,7 +0,0 @@
-import { isBrowser } from './env';
-
-export const output = {
-  write(str: string) {
-    return isBrowser ? undefined : process.stdout.write(str);
-  },
-};

package/src/redocly/__tests__/domains.test.ts

@@ -1,52 +0,0 @@
-import { RedoclyClient } from '../../index';
-import { setRedoclyDomain, getRedoclyDomain, getDomains, AVAILABLE_REGIONS } from '../domains';
-
-describe('domains', () => {
-  const REDOCLY_DOMAIN_US = 'redocly.com';
-  const TEST_DOMAIN = 'redoclyDomain.com';
-  const TEST_LAB_DOMAIN = 'lab.redocly.host';
-  const TEST_REDOC_ONLINE_DOMAIN = 'redoc.online';
-
-  afterEach(() => {
-    delete process.env.REDOCLY_DOMAIN;
-    setRedoclyDomain('');
-  });
-
-  it('should resolve the US domain by default', () => {
-    expect(getRedoclyDomain()).toBe(REDOCLY_DOMAIN_US);
-  });
-
-  it('should resolve the US and EU regions by default', () => {
-    expect(AVAILABLE_REGIONS).toStrictEqual(['us', 'eu']);
-  });
-
-  it('should resolve the specified domain if used with setter', () => {
-    setRedoclyDomain(TEST_DOMAIN);
-    expect(getRedoclyDomain()).toBe(TEST_DOMAIN);
-  });
-
-  it('should resolve the specified domain provided in environmental variable, after initializing RedoclyClient', () => {
-    process.env.REDOCLY_DOMAIN = TEST_DOMAIN;
-    const client = new RedoclyClient();
-    expect(getRedoclyDomain()).toBe(TEST_DOMAIN);
-    expect(client.domain).toBe(TEST_DOMAIN);
-  });
-
-  it('should return correct object when redocly domain is set to lab env', () => {
-    setRedoclyDomain(TEST_LAB_DOMAIN);
-    const domains = getDomains();
-    expect(domains).toEqual({ us: 'redocly.com', eu: 'eu.redocly.com', lab: 'lab.redocly.host' });
-    expect(getRedoclyDomain()).toBe(TEST_LAB_DOMAIN);
-  });
-
-  it('should return correct object when redocly domain is set to redoc.online env', () => {
-    setRedoclyDomain(TEST_REDOC_ONLINE_DOMAIN);
-    const domains = getDomains();
-    expect(domains).toEqual({
-      us: 'redocly.com',
-      eu: 'eu.redocly.com',
-      'redoc.online': 'redoc.online',
-    });
-    expect(getRedoclyDomain()).toBe(TEST_REDOC_ONLINE_DOMAIN);
-  });
-});

package/src/redocly/__tests__/redocly-client.test.ts

@@ -1,156 +0,0 @@
-import { setRedoclyDomain } from '../domains';
-import { RedoclyClient } from '../index';
-
-const originalFetch = global.fetch;
-
-describe('RedoclyClient', () => {
-  const REDOCLY_DOMAIN_US = 'redocly.com';
-  const REDOCLY_DOMAIN_EU = 'eu.redocly.com';
-  const REDOCLY_AUTHORIZATION_TOKEN = 'redocly-auth-token';
-  const testRedoclyDomain = 'redoclyDomain.com';
-  const testToken = 'test-token';
-
-  beforeAll(() => {
-    global.fetch = jest.fn(() =>
-      Promise.resolve({
-        ok: true,
-        json: jest.fn().mockResolvedValue({}),
-      } as any)
-    );
-  });
-
-  afterAll(() => {
-    global.fetch = originalFetch;
-  });
-
-  afterEach(() => {
-    delete process.env.REDOCLY_DOMAIN;
-    setRedoclyDomain('');
-  });
-
-  it('should resolve the US domain by default', () => {
-    const client = new RedoclyClient();
-    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
-  });
-
-  it('should resolve domain from RedoclyDomain env', () => {
-    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
-    const client = new RedoclyClient();
-    expect(client.domain).toBe(testRedoclyDomain);
-  });
-
-  it('should resolve a domain by US region', () => {
-    const client = new RedoclyClient('us');
-    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
-  });
-
-  it('should resolve a domain by EU region', () => {
-    const client = new RedoclyClient('eu');
-    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
-  });
-
-  it('should resolve domain by EU region prioritizing flag over env variable', () => {
-    setRedoclyDomain(testRedoclyDomain);
-    const client = new RedoclyClient('eu');
-    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
-  });
-
-  it('should resolve domain by US region prioritizing flag over env variable', () => {
-    setRedoclyDomain(testRedoclyDomain);
-    const client = new RedoclyClient('us');
-    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
-  });
-
-  it('should resolve domain by US region when REDOCLY_DOMAIN consists EU domain', () => {
-    setRedoclyDomain(REDOCLY_DOMAIN_EU);
-    const client = new RedoclyClient();
-    expect(client.getRegion()).toBe('eu');
-  });
-
-  it('should resolve all tokens', async () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
-      return { token: 'accessToken', us: 'accessToken', eu: 'eu-accessToken' };
-    });
-    const client = new RedoclyClient();
-    const tokens = client.getAllTokens();
-    expect(tokens).toStrictEqual([
-      { region: 'us', token: 'accessToken' },
-      { region: 'eu', token: 'eu-accessToken' },
-    ]);
-    spy.mockRestore();
-  });
-
-  it('should resolve valid tokens data', async () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
-      return { us: 'accessToken', eu: 'eu-accessToken' };
-    });
-    const client = new RedoclyClient();
-    const tokens = await client.getValidTokens();
-    expect(tokens).toStrictEqual([
-      { region: 'us', token: 'accessToken', valid: true },
-      { region: 'eu', token: 'eu-accessToken', valid: true },
-    ]);
-    spy.mockRestore();
-  });
-
-  it('should not call setAccessTokens by default', () => {
-    let spy = jest
-      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
-      .mockImplementation(() => ({}));
-    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
-    const client = new RedoclyClient();
-    expect(client.setAccessTokens).not.toHaveBeenCalled();
-    spy.mockRestore();
-  });
-
-  it('should set correct accessTokens - backward compatibility: default US region', () => {
-    let spy = jest
-      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
-      .mockImplementation(() => ({ token: testToken }));
-    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
-    const client = new RedoclyClient();
-    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ us: testToken }));
-    spy.mockRestore();
-  });
-
-  it('should set correct accessTokens - backward compatibility: EU region', () => {
-    let spy = jest
-      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
-      .mockImplementation(() => ({ token: testToken }));
-    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
-    const client = new RedoclyClient('eu');
-    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ eu: testToken }));
-    spy.mockRestore();
-  });
-
-  it('should set correct accessTokens - REDOCLY_AUTHORIZATION env', () => {
-    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation();
-    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
-    const client = new RedoclyClient();
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(1, { us: REDOCLY_AUTHORIZATION_TOKEN });
-    spy.mockRestore();
-  });
-
-  it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over token in file', () => {
-    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
-    let spy = jest
-      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
-      .mockImplementation(() => ({ token: testToken }));
-    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
-    const client = new RedoclyClient();
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { us: REDOCLY_AUTHORIZATION_TOKEN });
-    spy.mockRestore();
-  });
-
-  it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over EU token', () => {
-    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
-    let spy = jest
-      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
-      .mockImplementation(() => ({ us: testToken }));
-    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
-    const client = new RedoclyClient('eu');
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { eu: REDOCLY_AUTHORIZATION_TOKEN });
-    spy.mockRestore();
-  });
-});

package/src/redocly/domains.ts

@@ -1,48 +0,0 @@
-import type { Region } from '../config/types';
-
-let redoclyDomain = 'redocly.com';
-
-export const DEFAULT_REGION = 'us';
-
-export const DOMAINS = getDomains();
-export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
-
-export function getDomains() {
-  const domains: { [region in Region]: string } = {
-    us: 'redocly.com',
-    eu: 'eu.redocly.com',
-  };
-
-  // FIXME: temporary fix for our lab environments
-  const domain = redoclyDomain;
-  if (domain?.endsWith('.redocly.host')) {
-    domains[domain.split('.')[0] as Region] = domain;
-  }
-  if (domain === 'redoc.online') {
-    domains[domain as Region] = domain;
-  }
-  return domains;
-}
-
-export function setRedoclyDomain(domain: string) {
-  redoclyDomain = domain;
-}
-
-export function getRedoclyDomain(): string {
-  return redoclyDomain;
-}
-
-export function isRedoclyRegistryURL(link: string): boolean {
-  const domain = getRedoclyDomain() || DOMAINS[DEFAULT_REGION];
-
-  const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
-
-  if (
-    !link.startsWith(`https://api.${domain}/registry/`) &&
-    !link.startsWith(`https://api.${legacyDomain}/registry/`)
-  ) {
-    return false;
-  }
-
-  return true;
-}