@progress/kendo-typescript-tasks 10.0.22-dev.0 → 10.0.22-ng12.72

package/api.config.js

@@ -1,22 +1,8 @@
-const os = require('os');
 const path = require('path');
 
-const jsonPath = path.join(os.tmpdir(), `api-${process.pid}.json`);
+const jsonPath = path.resolve('./api.json');
 const typedoc = {
-    // TypeScript options
-    module: 'commonjs',
-    target: 'es6',
-    types: [],
-    experimentalDecorators: true,
-    jsx: 'react', // support for tsx files
-
-    // Output options
-    json: jsonPath,
-
-    // Typedoc options
-    excludeExternals: true,
-    ignoreCompilerErrors: false,
-    includeDeclarations: true
+    excludeExternals: false
 };
 
 module.exports = {

package/api.js

@@ -2,8 +2,9 @@
 
 const execSync = require('child_process').execSync;
 const path = require('path');
-const typedoc = require('gulp-typedoc');
 const { merge } = require('lodash');
+const typedoc = require('typedoc');
+const glob = require('glob');
 
 const api = require('./src/api/generator.js');
 const apiConfig = require('./api.config.js');
@@ -12,15 +13,34 @@ module.exports = (gulp, userConfig) => {
     const series = gulp.series;
 
     const config = merge({}, apiConfig, userConfig);
-    const DECLARATIONS = ["typings/index.d.ts", "node_modules/@types/core-js/index.d.ts"];
 
-    gulp.task('api-json', () => {
-        return gulp.src(["src/**/*.{ts,tsx}", ...DECLARATIONS, ...(config.externalApi || [])], { "allowEmpty": true })
-            .pipe(typedoc(config.typedoc));
+    gulp.task('api-json', async(done) => {
+        const entryPoints = [
+            ...glob.sync("src/**/*.{ts,tsx}"),
+            ...(config.externalApi || [])
+        ];
+
+        const app = new typedoc.Application();
+        app.options.addReader(new typedoc.TSConfigReader());
+        app.bootstrap({ ...config.typedoc, entryPoints });
+
+        const project = app.convert();
+        if (!project) {
+            done(new Error('Unable to initialize TypeDoc.'));
+            return;
+        }
+
+        await app.generateJson(project, apiConfig.jsonPath);
+        if (app.logger.hasErrors()) {
+            done(new Error('Unable to generate API reference, see messages above.'));
+            return;
+        }
+
+        done();
     });
 
     gulp.task('api-clean', (done) => {
-        execSync(`rm -rf docs/api`, {stdio:[0,1,2]});
+        execSync(`rm -rf docs/api`, { stdio: [ 0,1,2 ] });
         done();
     });
 
@@ -31,7 +51,7 @@ module.exports = (gulp, userConfig) => {
     }));
 
     gulp.task('api-check', series('api', (done) => {
-        execSync(`git diff --exit-code --color -- ${config.outPath}`,{stdio:[0,1,2]});
+        execSync(`git diff --exit-code --color -- ${config.outPath}`,{ stdio: [ 0,1,2 ] });
         done();
     }));
 };

package/gulp-tasks.js

@@ -3,11 +3,10 @@
 const del = require('del');
 const childProcess = require('child_process');
 const path = require('path');
-const gulpTsLint = require('gulp-tslint');
-const tslint = require('tslint');
 
 const apiTasks = require('./api.js');
 const commonTasks = require('@progress/kendo-common-tasks');
+const linter = require('./src/linter');
 
 const webpackConfig = require('./webpack.config.js');
 const tscPath = path.join(process.cwd(), 'node_modules', '.bin', 'tsc');
@@ -27,39 +26,25 @@ module.exports = (gulp, libraryName, compilerPath, options, webpackConfigPath) =
 
         childProcess.exec(`${cmd} -p ${tsConfigPath}`, err => {
             del.sync([ 'src/**/*.ngfactory.*', 'src/**/*.ngsummary.*',
-                       'dist/**/*.ngfactory.*', 'dist/**/*.ngsummary.*' ]);
-            done(err)
+                'dist/**/*.ngfactory.*', 'dist/**/*.ngsummary.*' ]);
+            done(err);
         });
     };
 
     gulp.task('check-compilation', (done) => {
-        childProcess.execSync(`${tscPath} --noEmit`, {stdio:[0,1,2]});
-        done()
+        childProcess.execSync(`${tscPath} --noEmit`, { stdio: [ 0,1,2 ] });
+        done();
     });
 
-    gulp.task('lint', series('check-compilation', (done) => {
-        const program = tslint.Linter.createProgram('./tsconfig.json', '.');
+    gulp.task('lint', series(
+        'check-compilation',
+        linter([ 'src/**/*.{ts,tsx}', 'test/**/*.{ts,tsx}', 'e2e/**/*.{ts,tsx}' ])
+    ));
 
-        return gulp.src([ 'src/**/*.{ts,tsx}', 'test/**/*.{ts,tsx}', 'e2e/**/*.{ts,tsx}' ])
-            .pipe(gulpTsLint({
-                program: program,
-                formatter: 'verbose'
-            }))
-            .pipe(gulpTsLint.report());
+    gulp.task('lint-docs', linter([ 'docs/examples/**/*.{ts,tsx}' ], {
+        overrideConfigFile: '.eslintrc.docs.json'
     }));
 
-    gulp.task('lint-docs', () => {
-        const program = tslint.Linter.createProgram('./tsconfig.docs.json', '.');
-
-        return gulp.src([ 'docs/examples/**/*.{ts,tsx}'])
-            .pipe(gulpTsLint({
-                formatter: 'prose',
-                program: program,
-                configuration: './tslint.docs.json'
-            }))
-            .pipe(gulpTsLint.report());
-    });
-
     gulp.task('start', (done) => {
         const webpackPort = 8888;
         const host = listenAddress;
@@ -68,10 +53,10 @@ module.exports = (gulp, libraryName, compilerPath, options, webpackConfigPath) =
 
         const config = Object.assign({}, webpackConfig.dev);
         config.resolve = Object.assign({}, config.resolve, {
-          alias: {
-            [packageInfo.name]: process.cwd() + '/src/main'
-          },
-          modules: [ path.join(process.cwd(), 'node_modules') ]
+            alias: {
+                [packageInfo.name]: process.cwd() + '/src/main'
+            },
+            modules: [ path.join(process.cwd(), 'node_modules') ]
         });
 
         const webpack = commonTasks.webpack(config);
@@ -86,7 +71,7 @@ module.exports = (gulp, libraryName, compilerPath, options, webpackConfigPath) =
         server.listen(webpackPort, host, err => {
             if (err) {
                 done();
-                throw new $.util.PluginError('webpack-dev-server', err);
+                throw new $.util.PluginError('webpack-dev-server', err); // eslint-disable-line no-undef
             }
         });
     });
@@ -95,5 +80,5 @@ module.exports = (gulp, libraryName, compilerPath, options, webpackConfigPath) =
     gulp.task('build-es-bundle', compile('tsconfig.es.json'));
     gulp.task('build-es2015-bundle', compile('tsconfig.es2015.json'));
     gulp.task('build-npm-bundle', compile('tsconfig.npm.json'));
-    gulp.task('build-package', series.apply(null, ['build-npm-bundle', 'build-es-bundle', 'build-cdn', 'build-systemjs-bundle']));
- };
+    gulp.task('build-package', series([ 'build-npm-bundle', 'build-es-bundle', 'build-cdn', 'build-systemjs-bundle' ]));
+};

package/gulpfile.js

@@ -3,13 +3,10 @@
 const gulp = require('gulp');
 const jasmine = require('gulp-jasmine');
 
-// kendo-common-task linter is ancient, skip it for now
-gulp.task('lint', (done) => done());
-
 gulp.task('test', () =>
     gulp.src('test/**/*.js')
-    .pipe(jasmine({
-        includeStackTrace: true
-    }))
+        .pipe(jasmine({
+            includeStackTrace: true
+        }))
 );
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@progress/kendo-typescript-tasks",
   "description": "Kendo UI TypeScript package gulp tasks",
   "main": "gulp-tasks.js",
-  "version": "10.0.22-dev.0+312a5e9",
+  "version": "10.0.22-ng12.72+c683c3c",
   "author": "Telerik",
   "license": "Apache-2.0",
   "scripts": {
@@ -15,29 +15,31 @@
     "API Generation"
   ],
   "peerDependencies": {
-    "typescript": "^3.4.5"
+    "typescript": "^4.3.4"
   },
   "dependencies": {
-    "@progress/kendo-common-tasks": "7.9.5-dev.3+312a5e9",
-    "core-js": "^2.2.2",
+    "@progress/kendo-common-tasks": "7.9.5-ng12.76+c683c3c",
+    "@typescript-eslint/eslint-plugin": "4.28.2",
+    "@typescript-eslint/parser": "4.28.2",
+    "core-js": "^3.18.0",
     "del": "2.2.2",
+    "eslint": "7.32.0",
+    "eslint-plugin-import": "2.25.2",
+    "eslint-plugin-rxjs": "3.3.7",
+    "glob": "^7.2.0",
     "gulp": "^4.0.0",
     "gulp-add-src": "^1.0.0",
-    "gulp-tslint": "^8.0.0",
-    "gulp-typedoc": "~2.2.2",
     "handlebars": "^4.0.5",
     "highlight.js": "9.14.2",
     "lodash": "^4.6.0",
     "mkdirp": "^0.5.0",
     "source-map-loader": "^0.1.5",
     "ts-loader": "4.1.0",
-    "tslint": "^5.0.0",
-    "tslint-defocus": "^2.0.6",
-    "typedoc": "0.15.0"
+    "typedoc": "~0.22.5"
   },
   "devDependencies": {
     "gulp-jasmine": "^2.4.2",
-    "typescript": "~3.4.5"
+    "typescript": "~4.3.4"
   },
   "repository": {
     "type": "git",
@@ -46,5 +48,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "312a5e97951ec3e69926d909e573bf5aafff222f"
+  "gitHead": "c683c3cf53173e65898d3a40a13a2c6654e98238"
 }

package/spec-bundle.js

@@ -31,5 +31,5 @@ function requireAll(requireContext) {
     return requireContext.keys().map(requireContext);
 }
 
-var modules = requireAll(testContext);
+let modules = requireAll(testContext); // eslint-disable-line no-unused-vars
 // requires and returns all modules that match

package/src/api/comment.js

@@ -27,7 +27,9 @@ const commentTags = (comment, member) =>
     });
 
 const formatComment = (member, parentName, memberKind) => {
-    const comment = member.comment;
+    const signatures = member.type?.declaration?.signatures;
+    const comment = member.comment || signatures && signatures[0]?.comment;
+
     if (!comment) {
         warn(member, parentName, memberKind);
 

package/src/api/component-page.js

@@ -22,12 +22,14 @@ const findDecorator = (decorators) => ((decorators || []).find(d =>
 const decoratorProp = (prop) => (decorators) => {
     const compDecorator = findDecorator(decorators);
 
-if (compDecorator) {
+    if (compDecorator) {
         const regExp = new RegExp(`${prop}:\\s?['"](.+?)['"]`);
         const match = compDecorator.arguments.obj.match(regExp);
 
         return match ? match[1] : undefined;
     }
+
+    return undefined;
 };
 
 const selector = decoratorProp('selector');

package/src/api/enum-page.js

@@ -9,7 +9,7 @@ function enumValues(member) {
             comment: comment(child),
             name: child.name
         };
-    })
+    });
 }
 
 const enumTemplate = template.compileFrom('enum-page.hbs');

package/src/api/generator.js

@@ -60,7 +60,7 @@ const traverseElements = (elements, callback) => {
             const value = element[field];
             if (Array.isArray(value)) {
                 traverseElements(value, callback);
-            } else if (typeof value == 'object') {
+            } else if (typeof value === 'object' && value !== null) {
                 traverseElements([ value ], callback);
             }
         }
@@ -71,7 +71,7 @@ const associateTypes = (elements, knownTypes) => {
     traverseElements(elements, element => {
         addTypeSlug(element, knownTypes);
     });
-}
+};
 
 const normalizeUnionReferences = (element, members) => {
     if (element.kind === 'union') {
@@ -79,19 +79,17 @@ const normalizeUnionReferences = (element, members) => {
         for (let idx = types.length - 1; idx >= 0; idx--) {
             const type = types[idx];
             if (type.type === 'reference') {
-                const unionReference = members.find((child) => {
-                    return child.name === type.name;
-                });
+                const unionReference = members.find((child) => child.name === type.name);
 
                 if (unionReference && unionReference.kind === 'union') {
                     normalizeUnionReferences(unionReference, members);
                     const toReplace = unionReference.type.types;
-                    types.splice.apply(types, [idx, 1].concat(toReplace));
+                    types.splice.apply(types, [ idx, 1 ].concat(toReplace));
                 }
             }
         }
     }
-}
+};
 
 const normalizeMembers = (members) => {
     traverseElements(members, (element) => {
@@ -99,9 +97,7 @@ const normalizeMembers = (members) => {
 
         if (!element.comment && element.implementationOf) {
             const interfaceName = element.implementationOf.name.split('.')[0];
-            const interfaceOptions = members.find((child) => {
-                return child.name === interfaceName;
-            });
+            const interfaceOptions = members.find((child) => child.name === interfaceName);
 
             if (interfaceOptions) {
                 const baseOption = interfaceOptions.children.find(child => child.name === element.name);
@@ -110,8 +106,13 @@ const normalizeMembers = (members) => {
                 }
             }
         }
+
+        if (!element.comment && element.kindString === 'Accessor') {
+            const accessor = element.getSignature || element.setSignature || [];
+            element.comment = accessor[0].comment;
+        }
     });
-}
+};
 
 const mergeComments = (root, src) => {
     if (!root.comment && src.comment) {
@@ -123,23 +124,20 @@ const mergeComments = (root, src) => {
             mergeComments(root[key], src[key]);
         }
     });
-}
-
-const moduleRoot = (moduleName, rootModules) => {
-    return rootModules.includes(moduleName) ? moduleName :
-        rootModules.find(rootModule => moduleName.indexOf(rootModule) > -1);
 };
 
+const moduleRoot = (moduleName, rootModules) => (rootModules.includes(moduleName) ? moduleName :
+    rootModules.find(rootModule => moduleName.indexOf(rootModule) > -1));
+
 const moduleFullName = (moduleName, packageName, rootModules) => {
     const rootModule = moduleRoot(moduleName, rootModules);
     let fullName = packageName;
-    if (rootModule)
-    {
+    if (rootModule) {
         fullName += '_' + rootModule;
     }
 
     return fullName;
-}
+};
 
 const extractMembers = (packageName, modules, config) => {
     const knownTypes = {};
@@ -148,8 +146,9 @@ const extractMembers = (packageName, modules, config) => {
 
     const models = nonEmptyModules.map(module => module
         .children
-        .filter(child => child.flags.isExported)
+        .filter(child => child.kindString !== "Reference")
         .filter(child => child.name !== 'core')
+        .filter(child => !child.sources[0].fileName.includes('prosemirror'))
         .map(child => {
             const fullName = moduleFullName(module.name, packageName, rootModules);
 
@@ -182,7 +181,7 @@ const extractMembers = (packageName, modules, config) => {
     const members = utils.flatten(models)
         .sort(utils.nameComparer)
         .map(model => {
-            associateTypes([model], knownTypes);
+            associateTypes([ model ], knownTypes);
             return model;
         });
 
@@ -195,7 +194,6 @@ const namespacesAsModules = data => {
     const modules = [];
     data.filter(moduleFilter).forEach(module => module
         .children
-        .filter(child => child.flags.isExported)
         .filter(child => child.name !== 'core')
         .forEach(child => {
             if (child.kindString === 'Module' && child.children) {
@@ -227,6 +225,18 @@ const groupMembers = (members) => {
     return membersByModule;
 };
 
+const packagePlatform = (packageInfo) => {
+    let platform = '';
+
+    if (/-angular-/.test(packageInfo.name)) {
+        platform = 'Angular';
+    } else if (/-react-/.test(packageInfo.name)) {
+        platform = 'React';
+    }
+
+    return platform;
+};
+
 const generate = (done, config, packageInfo) => {
     const meta = require(config.jsonPath);
     const namespaces = namespacesAsModules(meta.children);
@@ -234,8 +244,7 @@ const generate = (done, config, packageInfo) => {
     const membersByModule = config.reorderModules ?
         config.reorderModules(groupMembers(members)) : groupMembers(members);
     const outPath = config.outPath;
-    const platform = /-angular-/.test(packageInfo.name) ? 'Angular' :
-                       /-react-/.test(packageInfo.name) ? 'React'   : '';
+    const platform = packagePlatform(packageInfo);
     const info = Object.assign({ platform }, packageInfo['@progress']);
 
     writeFile(`${outPath}/index.md`, indexPage(packageInfo.name, membersByModule, info));

package/src/api/map-constructors.js

@@ -2,16 +2,19 @@
 
 const comment = require('./comment');
 const isPublic = require('./is-public');
-const isInput = require('./is-input');
 const types = require('./type-utils');
 const utils = require('./utils');
 
 const isConstructor = (prop) =>
     prop.kindString && prop.kindString === 'Constructor' && isPublic(prop);
 
-const mapConstructors = (member) =>
-    utils.flatten(member.children.filter(isConstructor).map(ctr => {
-        const name = ctr.name;
+const mapConstructors = (member) => {
+    if (member.decorators && member.decorators.find(d => d.name === 'NgModule')) {
+        // Ignore NgModule constructors
+        return [];
+    }
+
+    return utils.flatten(member.children.filter(isConstructor).map(ctr => {
         const source = `${member.name}.constructor`;
 
         return ctr.signatures.map((signature) => ({
@@ -21,6 +24,7 @@ const mapConstructors = (member) =>
             params: types.params(signature, source)
         }));
     }));
+};
 
 module.exports = mapConstructors;
 

package/src/api/map-props.js

@@ -15,12 +15,13 @@ const defaultValue = prop => {
     return text && ` (default: ${text.trim()})`;
 };
 
-const accessor = signature => Array.isArray(signature) ? signature[0] : signature;
+const accessor = signature => (Array.isArray(signature) ? signature[0] : signature);
 
 const isProp = (prop) => isPublic(prop) && !isConstructor(prop) && !isMethod(prop);
 const mapProps = (children, parentName) =>
     children.filter(isProp).map(prop => {
         let type;
+        let commentProp = prop;
         if (prop.type) {
             type = types.typeString(prop);
         } else if (prop.kindString === 'Accessor') {
@@ -28,12 +29,13 @@ const mapProps = (children, parentName) =>
             const setter = prop.setSignature;
 
             // Fingers crossed
-            type = types.typeString(getter ?
-                accessor(getter) :
-                accessor(setter).parameters[0]
+            type = types.typeString(setter ?
+                accessor(setter).parameters[0] :
+                accessor(getter)
             );
         } else if (prop.kindString === 'Method') {
             type = types.callType(prop.signatures[0]);
+            commentProp = prop.signatures[0];
         }
 
         let name = prop.name;
@@ -53,7 +55,7 @@ const mapProps = (children, parentName) =>
             name: name,
             type: type,
             defaultValue: defaultValue(prop),
-            comment: comment(prop, parentName)
+            comment: comment(commentProp, parentName)
         };
     });
 

package/src/api/member-page.js

@@ -1,7 +1,6 @@
 "use strict";
 
 const path = require('path');
-const template = require('./template-utils');
 const componentPage = require('./component-page');
 const constantPage = require('./constant-page');
 const classPage = require('./class-page');

package/src/api/return-type.js

@@ -16,7 +16,7 @@ const returnType = (definition, parentName) => {
     if (!comment && definition.type.name !== 'void') {
         let source = `${definition.name}`;
         if (parentName) {
-          source = `${parentName } - ${source}`;
+            source = `${parentName } - ${source}`;
         }
         utils.warn('Undocumented return type', source);
     }

package/src/api/template-utils.js

@@ -8,7 +8,10 @@ hbs.registerHelper('capitalize',
     s => s.slice(0,1).toUpperCase() + s.slice(1));
 
 hbs.registerHelper('contains',
-    (s, chars, options) => s.includes(chars) ? options.fn(s) : options.inverse(s));
+    (s, chars, options) => (s.includes(chars) ? options.fn(s) : options.inverse(s)));
+
+hbs.registerHelper('equals',
+    (s, comparer, options) => (s === comparer ? options.fn(s) : options.inverse(s)));
 
 const readLocal = (src) =>
     fs.readFileSync(path.join(__dirname, src), { encoding: 'utf-8' });

package/src/api/type-utils.js

@@ -5,7 +5,7 @@ const comment = require('./comment');
 const unionTypes = (member) =>
     member.type.types.map(type => {
         switch (type.type) {
-        case 'stringLiteral':
+        case 'literal':
             return `"${type.value}"`;
         default:
             return typeString({ type });
@@ -92,6 +92,10 @@ const INTERSECTION = ' [intersected](https://www.typescriptlang.org/docs/handboo
 const singleTypeString = (type) => {
     let suffix = '';
 
+    if (type.type === 'literal') {
+        return type.value;
+    }
+
     if (type.type === 'intersection') {
         return unionTypes({ type }).join(INTERSECTION);
     }
@@ -100,7 +104,7 @@ const singleTypeString = (type) => {
         const decl = type.declaration;
         if (decl.signatures) {
             const sig = decl.signatures[0];
-            if (decl.name === '__type' && sig.name === '__call') {
+            if (decl.name === '__type' && sig.kindString === 'Call signature') {
                 return callType(sig);
             }
         } else if (decl.indexSignature) {
@@ -115,13 +119,13 @@ const singleTypeString = (type) => {
         }
     }
 
+    if (type.type === 'array') {
+        return `${singleTypeString(type.elementType)}[]`;
+    }
+
     if (type.typeArguments) {
         suffix = `<${singleTypeString(type.typeArguments[0])}>`;
     }
-    
-    if (type.type === 'array') {
-        suffix += '[]';
-    }
 
     const name = typeName(type);
 
@@ -135,8 +139,8 @@ const typeString = (prop) => {
         return unionTypes(prop).join(' | ');
     }
 
-    if (type.type === 'stringLiteral') {
-        return `'${type.value}'`;
+    if (type.type === 'literal') {
+        return `"${type.value}"`;
     }
 
     return singleTypeString(prop.type);
@@ -153,7 +157,7 @@ const fullName = (member) => {
     }
 
     return member.name + suffix;
-}
+};
 
 module.exports = {
     callSignature: callSignature,

package/src/api/union-page.hbs

@@ -6,6 +6,7 @@
 `type` {{name}} =
   {{~#each types~}}
     {{~#contains this 'slug'}} {{this}}
+      {{~else equals this '"null"'}} `null`
       {{~else contains this '"'}} {{this}}
       {{~else}} `{{this}}`
     {{~/contains~}}

package/src/api/utils.js

@@ -9,15 +9,15 @@ const not = predicate => member => !predicate(member);
 
 const ignore = predicate => props => (props || []).filter(predicate);
 
-const hasProp = prop => obj => !!obj[prop];
+const hasProp = prop => obj => Boolean(obj[prop]);
 
 const groupBy = (predicate, list) =>
     list.reduce((acc, item) => {
-      const field = predicate(item);
-      acc[field] = acc[field] || [];
-      acc[field].push(item);
-      return acc;
-    }, {})
+        const field = predicate(item);
+        acc[field] = acc[field] || [];
+        acc[field].push(item);
+        return acc;
+    }, {});
 
 const WARNINGS = [];
 const warn = (type, text) => {

package/src/linter.js

@@ -0,0 +1,18 @@
+const { ESLint } = require('eslint');
+
+const linter = (files, options = {}) => async function lint(done) {
+    const eslint = new ESLint(options);
+    const results = await eslint.lintFiles(files);
+    const formatter = await eslint.loadFormatter('stylish');
+    const errors = ESLint.getErrorResults(results);
+    const resultText = formatter.format(results);
+    console.log(resultText);
+
+    if (errors.length > 0) {
+        done(new Error('Lint failed.'));
+    } else {
+        done();
+    }
+};
+
+module.exports = linter;

package/stub-loader.js

@@ -1,4 +1,4 @@
 
 module.exports = function() {
-  return '{}';
+    return '{}';
 };

package/test/api.js

@@ -51,7 +51,7 @@ describe('API generation', () => {
 
     describe('for modules', () => {
         const pkg = require('./package.json');
-        const members = generator.extractMembers(pkg.name, pkg.children, { modules: ['module1'] });
+        const members = generator.extractMembers(pkg.name, pkg.children, { modules: [ 'module1' ] });
 
         it('adds module to slug', () => {
             expect(members[0].slug).toEqual('api_package-name_module1_foo');
@@ -170,6 +170,12 @@ describe('API generation', () => {
             const page = unionPage(intersectionData);
             expect(page).toContain('ColumnSortSettings [intersected](https://www.typescriptlang.org/docs/handbook/advanced-types.html#intersection-types) with { mode?: "single" | "multiple"; }');
         });
+
+        it('formats values conatining or equaling "null"', () => {
+            const unionData = require('./type-union-operators.json');
+            const page = unionPage(unionData);
+            expect(page).toContain('`type` FilterOperator = "gt" | "gte" | "isnull" | "isnotnull" | `null`');
+        });
     });
 
     describe('for components', () => {
@@ -325,22 +331,22 @@ describe('API generation', () => {
     describe('index', () => {
         const page = indexPage('foo/bar', {
             '': {
-                'Function': [{
+                'Function': [ {
                     'slug': 'root-f',
                     'name': 'root-f'
-                }]
+                } ]
             },
             'a': {
-                'Function': [{
+                'Function': [ {
                     'slug': 'a-f',
                     'name': 'a-f'
-                }]
+                } ]
             },
             'b': {
-                'Function': [{
+                'Function': [ {
                     'slug': 'b-f',
                     'name': 'b-f'
-                }]
+                } ]
             }
         }, {
             friendlyName: 'Foo',
@@ -348,7 +354,7 @@ describe('API generation', () => {
         });
 
         const assertModule = name => {
-            expect(new RegExp(`<h2 class=\"module-name\">\\s*${name}\\s*<\\/h2>`).test(page)).toBeTruthy();
+            expect(new RegExp(`<h2 class="module-name">\\s*${name}\\s*<\\/h2>`).test(page)).toBeTruthy();
         };
 
         it('renders default group', () => {

package/test/intersection.json

@@ -46,11 +46,11 @@
                                         "type": "union",
                                         "types": [
                                             {
-                                                "type": "stringLiteral",
+                                                "type": "literal",
                                                 "value": "single"
                                             },
                                             {
-                                                "type": "stringLiteral",
+                                                "type": "literal",
                                                 "value": "multiple"
                                             }
                                         ]

package/test/type-union-operators.json

@@ -0,0 +1,42 @@
+{
+    "id": 416,
+    "name": "FilterOperator",
+    "kind": 4194304,
+    "kindString": "Type alias",
+    "flags": {},
+    "comment": {
+        "shortText": "Represents the FilterOperator type."
+    },
+    "sources": [
+        {
+            "fileName": "src/model/filter-expression.ts",
+            "line": 5,
+            "character": 12
+        }
+    ],
+    "type": {
+        "type": "union",
+        "types": [
+            {
+                "type": "literal",
+                "value": "gt"
+            },
+            {
+                "type": "literal",
+                "value": "gte"
+            },
+            {
+                "type": "literal",
+                "value": "isnull"
+            },
+            {
+                "type": "literal",
+                "value": "isnotnull"
+            },
+            {
+                "type": "literal",
+                "value": null
+            }
+        ]
+    }
+}

package/test/type-union.json

@@ -52,11 +52,11 @@
                                 "type": "union",
                                 "types": [
                                     {
-                                        "type": "stringLiteral",
+                                        "type": "literal",
                                         "value": "single"
                                     },
                                     {
-                                        "type": "stringLiteral",
+                                        "type": "literal",
                                         "value": "multiple"
                                     }
                                 ]