feat: switch to named imports

README.md

@@ -208,24 +208,24 @@ As input a [json file](https://github.com/contentful/contentful-cli/tree/master/
 
 ```typescript
 import * as CFRichTextTypes from '@contentful/rich-text-types';
-import * as Contentful from 'contentful';
+import { Entry, EntryFields } from 'contentful';
 
 export interface TypeArtistFields {
   name: Contentful.EntryFields.Symbol;
   profilePicture?: Contentful.Asset;
   bio?: CFRichTextTypes.Block | CFRichTextTypes.Inline;
 }
 
-export type TypeArtist = Contentful.Entry<TypeArtistFields>;
+export type TypeArtist = Entry<TypeArtistFields>;
 
 export interface TypeArtworkFields {
-  name: Contentful.EntryFields.Symbol;
+  name: EntryFields.Symbol;
   type?: 'print' | 'drawing' | 'painting';
-  preview?: Contentful.Asset[];
-  artist: Contentful.Entry<TypeArtistFields>;
+  preview?: Asset[];
+  artist: Entry<TypeArtistFields>;
 }
 
-export type TypeArtwork = Contentful.Entry<TypeArtworkFields>;
+export type TypeArtwork = Entry<TypeArtworkFields>;
 ```
 
 This all only works if you add the [`contentful`](https://www.npmjs.com/package/contentful) package to your target project to get all relevant type definitions.
@@ -404,13 +404,14 @@ const stringContent = new CFDefinitionsBuilder()
 
 console.log(stringContent);
 
-// import * as Contentful from "contentful";
+// import { Entry, EntryFields } from "contentful";
+
 //
 // export interface TypeMyEntryFields {
-//   myField: Contentful.EntryFields.Symbol;
+//   myField: EntryFields.Symbol;
 // }
 //
-// export type TypeMyEntry = Contentful.Entry<TypeMyEntryFields>;
+// export type TypeMyEntry = Entry<TypeMyEntryFields>;
 ```
 
 # Browser Usage

src/cli.ts

@@ -8,7 +8,7 @@ import {
   DefaultContentTypeRenderer,
   JsDocRenderer,
   LocalizedContentTypeRenderer,
-} from './renderer/type';
+} from './renderer';
 
 // eslint-disable-next-line unicorn/prefer-module
 const contentfulExport = require('contentful-export');

src/property-imports.ts

@@ -10,10 +10,11 @@ export const propertyImports = (
 ): OptionalKind<ImportDeclarationStructure>[] => {
   const filterIgnoredModule = (name: string) => ignoreModule !== context.moduleName(name);
 
-  const moduleImport = (module: string) => {
+  const moduleImport = (module: string): OptionalKind<ImportDeclarationStructure> => {
     return {
       moduleSpecifier: `./${context.moduleName(module)}`,
       namedImports: [context.moduleFieldsName(module)],
+      isTypeOnly: true,
     };
   };
 

src/renderer/field/render-prop-any.ts

@@ -1,7 +1,8 @@
-import { renderTypeLiteral, renderTypeUnion } from '../generic';
 import { Field } from 'contentful';
+import { renderTypeLiteral, renderTypeUnion } from '../generic';
+import { RenderContext } from '../type';
 
-export const renderPropAny = (field: Field): string => {
+export const renderPropAny = (field: Field, context: RenderContext): string => {
   if (field.validations?.length > 0) {
     const includesValidation = field.validations.find((validation) => validation.in);
     if (includesValidation && includesValidation.in) {
@@ -17,5 +18,11 @@ export const renderPropAny = (field: Field): string => {
     }
   }
 
-  return `Contentful.EntryFields.${field.type}`;
+  context.imports.add({
+    moduleSpecifier: 'contentful',
+    namedImports: ['EntryFields'],
+    isTypeOnly: true,
+  });
+
+  return `EntryFields.${field.type}`;
 };

src/renderer/field/render-prop-array.ts

@@ -25,7 +25,13 @@ export const renderPropArray = (field: Field, context: RenderContext): string =>
       return renderTypeArray(`${renderTypeUnion(validationsTypes)}`);
     }
 
-    return renderTypeArray('Contentful.EntryFields.Symbol');
+    context.imports.add({
+      moduleSpecifier: 'contentful',
+      namedImports: ['EntryFields'],
+      isTypeOnly: true,
+    });
+
+    return renderTypeArray('EntryFields.Symbol');
   }
 
   throw new Error('unhandled array type "' + field.items.type + '"');

src/renderer/field/render-prop-link.ts

@@ -14,7 +14,24 @@ export const renderPropLink = (
       : 'Record<string, any>';
   };
 
-  return field.linkType === 'Entry'
-    ? renderTypeGeneric('Contentful.' + field.linkType, linkContentType(field, context))
-    : 'Contentful.' + field.linkType!;
+  switch (field.linkType) {
+    case 'Entry':
+      context.imports.add({
+        moduleSpecifier: 'contentful',
+        namedImports: ['Entry'],
+        isTypeOnly: true,
+      });
+      return renderTypeGeneric(field.linkType, linkContentType(field, context));
+
+    case 'Asset':
+      context.imports.add({
+        moduleSpecifier: 'contentful',
+        namedImports: ['Asset'],
+        isTypeOnly: true,
+      });
+      return 'Asset';
+
+    default:
+      throw new Error(`Unknown linkType "${field.linkType}"`);
+  }
 };

src/renderer/field/render-prop-richtext.ts

@@ -6,6 +6,7 @@ export const renderRichText = (field: Field, context: RenderContext): string =>
   context.imports.add({
     moduleSpecifier: '@contentful/rich-text-types',
     namespaceImport: 'CFRichTextTypes',
+    isTypeOnly: true,
   });
   return renderTypeUnion(['CFRichTextTypes.Block', 'CFRichTextTypes.Inline']);
 };

src/renderer/type/default-content-type-renderer.ts

@@ -44,12 +44,8 @@ export class DefaultContentTypeRenderer extends BaseContentTypeRenderer {
     }
   }
 
-  protected addDefaultImports(context: RenderContext): void {
-    context.imports.add({
-      moduleSpecifier: 'contentful',
-      namespaceImport: 'Contentful',
-    });
-  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-function
+  protected addDefaultImports(context: RenderContext): void {}
 
   protected renderField(
     field: Field,
@@ -78,6 +74,11 @@ export class DefaultContentTypeRenderer extends BaseContentTypeRenderer {
   }
 
   protected renderEntryType(contentType: CFContentType, context: RenderContext): string {
-    return renderTypeGeneric('Contentful.Entry', context.moduleFieldsName(contentType.sys.id));
+    context.imports.add({
+      moduleSpecifier: 'contentful',
+      namedImports: ['Entry'],
+      isTypeOnly: true,
+    });
+    return renderTypeGeneric('Entry', context.moduleFieldsName(contentType.sys.id));
   }
 }

src/renderer/type/localized-content-type-renderer.ts

@@ -73,6 +73,7 @@ export class LocalizedContentTypeRenderer extends BaseContentTypeRenderer {
     context.imports.add({
       moduleSpecifier: `./${this.FILE_BASE_NAME}`,
       namedImports: ['LocalizedFields', 'LocalizedEntry'],
+      isTypeOnly: true,
     });
 
     for (const structure of context.imports) {

test/cases/fixtures/01-output.txt

@@ -1,38 +1,38 @@
-import * as Contentful from "contentful";
+import type { Asset, Entry, EntryFields } from "contentful";
 
 export interface TypeBrandFields {
-    companyName: Contentful.EntryFields.Text;
-    logo?: Contentful.Asset;
-    companyDescription?: Contentful.EntryFields.Text;
-    website?: Contentful.EntryFields.Symbol;
-    twitter?: Contentful.EntryFields.Symbol;
-    email?: Contentful.EntryFields.Symbol;
-    phone?: Contentful.EntryFields.Symbol[];
+    companyName: EntryFields.Text;
+    logo?: Asset;
+    companyDescription?: EntryFields.Text;
+    website?: EntryFields.Symbol;
+    twitter?: EntryFields.Symbol;
+    email?: EntryFields.Symbol;
+    phone?: EntryFields.Symbol[];
 }
 
-export type TypeBrand = Contentful.Entry<TypeBrandFields>;
+export type TypeBrand = Entry<TypeBrandFields>;
 
 export interface TypeCategoryFields {
-    title: Contentful.EntryFields.Text;
-    icon?: Contentful.Asset;
-    categoryDescription?: Contentful.EntryFields.Text;
+    title: EntryFields.Text;
+    icon?: Asset;
+    categoryDescription?: EntryFields.Text;
 }
 
-export type TypeCategory = Contentful.Entry<TypeCategoryFields>;
+export type TypeCategory = Entry<TypeCategoryFields>;
 
 export interface TypeProductFields {
-    productName: Contentful.EntryFields.Text;
-    slug?: Contentful.EntryFields.Symbol;
-    productDescription?: Contentful.EntryFields.Text;
-    sizetypecolor?: Contentful.EntryFields.Symbol;
-    image?: Contentful.Asset[];
-    tags?: Contentful.EntryFields.Symbol[];
-    categories?: Contentful.Entry<TypeCategoryFields>[];
-    price?: Contentful.EntryFields.Number;
-    brand?: Contentful.Entry<TypeBrandFields>;
-    quantity?: Contentful.EntryFields.Integer;
-    sku?: Contentful.EntryFields.Symbol;
-    website?: Contentful.EntryFields.Symbol;
+    productName: EntryFields.Text;
+    slug?: EntryFields.Symbol;
+    productDescription?: EntryFields.Text;
+    sizetypecolor?: EntryFields.Symbol;
+    image?: Asset[];
+    tags?: EntryFields.Symbol[];
+    categories?: Entry<TypeCategoryFields>[];
+    price?: EntryFields.Number;
+    brand?: Entry<TypeBrandFields>;
+    quantity?: EntryFields.Integer;
+    sku?: EntryFields.Symbol;
+    website?: EntryFields.Symbol;
 }
 
-export type TypeProduct = Contentful.Entry<TypeProductFields>;
+export type TypeProduct = Entry<TypeProductFields>;