chore: reduce bundle size

Author: DmitryAnansky

packages/cli/src/commands/stats.ts

@@ -98,7 +98,10 @@ export async function handleStats({ argv, config, collectSpecData }: CommandArgs
   const { bundle: document } = await bundle({ config, ref: path });
   collectSpecData?.(document.parsed);
   const specVersion = detectSpec(document.parsed);
-  const types = normalizeTypes(config.extendTypes(getTypes(specVersion), specVersion), config);
+  const types = normalizeTypes(
+    config.extendTypes(await getTypes(specVersion), specVersion),
+    config
+  );
 
   const startedAt = performance.now();
   const ctx: WalkContext = {

packages/core/package.json

@@ -10,6 +10,11 @@
       "require": "./lib/index.js",
       "types": "./lib/index.d.ts"
     },
+    "./resolve": {
+      "import": "./lib/resolve.js",
+      "require": "./lib/resolve.js",
+      "types": "./lib/resolve.d.ts"
+    },
     "./lib/config/config": {
       "import": "./lib/config/index.js",
       "require": "./lib/config/index.js",

packages/core/src/__tests__/lint.test.ts

@@ -1160,7 +1160,7 @@ describe('lint', () => {
   it('lintConfig should alternate its behavior when supplied externalConfigTypes', async () => {
     const config = await createConfig(testPortalConfigContent);
     const results = await lintConfig({
-      externalConfigTypes: createConfigTypes(
+      externalConfigTypes: await createConfigTypes(
         {
           type: 'object',
           properties: {

packages/core/src/bundle.ts

@@ -167,7 +167,7 @@ export async function bundleDocument(opts: {
   const specMajorVersion = getMajorSpecVersion(specVersion);
   const rules = config.getRulesForSpecVersion(specMajorVersion);
   const types = normalizeTypes(
-    config.extendTypes(customTypes ?? getTypes(specVersion), specVersion),
+    config.extendTypes(customTypes ?? (await getTypes(specVersion)), specVersion),
     config
   );
 

packages/core/src/lint.ts

@@ -76,7 +76,7 @@ export async function lintDocument(opts: {
   const specMajorVersion = getMajorSpecVersion(specVersion);
   const rules = config.getRulesForSpecVersion(specMajorVersion);
   const types = normalizeTypes(
-    config.extendTypes(customTypes ?? getTypes(specVersion), specVersion),
+    config.extendTypes(customTypes ?? (await getTypes(specVersion)), specVersion),
     config
   );
 
@@ -143,7 +143,7 @@ export async function lintConfig(opts: {
   };
 
   const types = normalizeTypes(
-    opts.externalConfigTypes || createConfigTypes(rootRedoclyConfigSchema, config)
+    opts.externalConfigTypes || (await createConfigTypes(rootRedoclyConfigSchema, config))
   );
 
   const rules: (RuleInstanceConfig & {

packages/core/src/oas-types.ts

@@ -1,11 +1,3 @@
-import { Oas2Types } from './types/oas2.js';
-import { Oas3Types } from './types/oas3.js';
-import { Oas3_1Types } from './types/oas3_1.js';
-import { Oas3_2Types } from './types/oas3_2.js';
-import { AsyncApi2Types } from './types/asyncapi2.js';
-import { AsyncApi3Types } from './types/asyncapi3.js';
-import { Arazzo1Types } from './types/arazzo.js';
-import { Overlay1Types } from './types/overlay.js';
 import { isPlainObject } from './utils.js';
 import { VERSION_PATTERN } from './typings/arazzo.js';
 
@@ -47,17 +39,6 @@ export type SpecVersion = typeof specVersions[number];
 
 export type SpecMajorVersion = 'oas2' | 'oas3' | 'async2' | 'async3' | 'arazzo1' | 'overlay1';
 
-const typesMap = {
-  oas2: Oas2Types,
-  oas3_0: Oas3Types,
-  oas3_1: Oas3_1Types,
-  oas3_2: Oas3_2Types,
-  async2: AsyncApi2Types,
-  async3: AsyncApi3Types,
-  arazzo1: Arazzo1Types,
-  overlay1: Overlay1Types,
-};
-
 export type RuleMap<Key extends string, RuleConfig, T> = Record<
   T extends 'built-in' ? Key : string,
   RuleConfig
@@ -175,6 +156,25 @@ export function getMajorSpecVersion(version: SpecVersion): SpecMajorVersion {
   }
 }
 
-export function getTypes(spec: SpecVersion) {
-  return typesMap[spec];
+export async function getTypes(spec: SpecVersion) {
+  switch (spec) {
+    case 'oas2':
+      return (await import('./types/oas2.js')).Oas2Types;
+    case 'oas3_0':
+      return (await import('./types/oas3.js')).Oas3Types;
+    case 'oas3_1':
+      return (await import('./types/oas3_1.js')).Oas3_1Types;
+    case 'oas3_2':
+      return (await import('./types/oas3_2.js')).Oas3_2Types;
+    case 'async2':
+      return (await import('./types/asyncapi2.js')).AsyncApi2Types;
+    case 'async3':
+      return (await import('./types/asyncapi3.js')).AsyncApi3Types;
+    case 'arazzo1':
+      return (await import('./types/arazzo.js')).Arazzo1Types;
+    case 'overlay1':
+      return (await import('./types/overlay.js')).Overlay1Types;
+    default:
+      throw new Error(`Unsupported specification: ${spec}`);
+  }
 }

packages/core/src/types/redocly-yaml.ts

@@ -426,11 +426,17 @@ const Assert: NodeType = {
   required: ['subject', 'assertions'],
 };
 
-export function createConfigTypes(extraSchemas: JSONSchema, config?: Config) {
-  const nodeNames = specVersions.flatMap((version) => {
-    const types = config ? config.extendTypes(getTypes(version), version) : getTypes(version);
-    return Object.keys(types);
-  });
+export async function createConfigTypes(extraSchemas: JSONSchema, config?: Config) {
+  const nodeNames = (
+    await Promise.all(
+      specVersions.map(async (version) => {
+        const types = config
+          ? config.extendTypes(await getTypes(version), version)
+          : await getTypes(version);
+        return Object.keys(types);
+      })
+    )
+  ).flat();
   // Create types based on external schemas
   const nodeTypes = getNodeTypesFromJSONSchema('rootRedoclyConfigSchema', extraSchemas);
 
@@ -460,5 +466,37 @@ const CoreConfigTypes: Record<string, NodeType> = {
 // @ts-ignore FIXME: remove this once we remove `theme` from the schema
 delete rootRedoclyConfigSchema.properties.theme;
 
-export const ConfigTypes: Record<string, NodeType> = createConfigTypes(rootRedoclyConfigSchema);
+// Lazy-loaded config types to support dynamic imports
+let _configTypesPromise: Promise<Record<string, NodeType>> | null = null;
+let _normalizedConfigTypes: ReturnType<typeof normalizeTypes> | null = null;
+
+export function getConfigTypes(): Promise<Record<string, NodeType>> {
+  if (!_configTypesPromise) {
+    _configTypesPromise = createConfigTypes(rootRedoclyConfigSchema);
+  }
+  return _configTypesPromise;
+}
+
+export async function getNormalizedConfigTypes() {
+  if (!_normalizedConfigTypes) {
+    const configTypes = await getConfigTypes();
+    _normalizedConfigTypes = normalizeTypes(configTypes);
+  }
+  return _normalizedConfigTypes;
+}
+
+// Synchronous exports for backwards compatibility (minimal set for sync initialization)
+// Note: This only includes core config types without spec-specific node names
+// For full type support with all specs, use getConfigTypes() or getNormalizedConfigTypes()
+const nodeTypes = getNodeTypesFromJSONSchema('rootRedoclyConfigSchema', rootRedoclyConfigSchema);
+
+export const ConfigTypes: Record<string, NodeType> = {
+  ...CoreConfigTypes,
+  ConfigRoot: createConfigRoot(nodeTypes),
+  ConfigApisProperties: createConfigApisProperties(nodeTypes),
+  AssertionDefinitionSubject: createAssertionDefinitionSubject([]), // Empty for sync version
+  ...nodeTypes,
+  'rootRedoclyConfigSchema.scorecard.levels_items': createScorecardLevelsItems(nodeTypes),
+};
+
 export const NormalizedConfigTypes = normalizeTypes(ConfigTypes);