Deployed the page to Github Pages.

node_modules/tslint/lib/rules/completed-docs/blockExclusion.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2017 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as ts from "typescript";
+import { Visibility } from "../completedDocsRule";
+import { Exclusion } from "./exclusion";
+export interface IBlockExclusionDescriptor {
+    visibilities?: Visibility[];
+}
+export declare class BlockExclusion extends Exclusion<IBlockExclusionDescriptor> {
+    readonly visibilities: Set<Visibility>;
+    excludes(node: ts.Node): boolean;
+}

node_modules/tslint/lib/rules/completed-docs/blockExclusion.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2017 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockExclusion = void 0;
+var tslib_1 = require("tslib");
+var tsutils_1 = require("tsutils");
+var ts = require("typescript");
+var completedDocsRule_1 = require("../completedDocsRule");
+var exclusion_1 = require("./exclusion");
+var BlockExclusion = /** @class */ (function (_super) {
+    tslib_1.__extends(BlockExclusion, _super);
+    function BlockExclusion() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.visibilities = _this.createSet(_this.descriptor.visibilities);
+        return _this;
+    }
+    BlockExclusion.prototype.excludes = function (node) {
+        if (this.visibilities.has(completedDocsRule_1.ALL)) {
+            return false;
+        }
+        if (tsutils_1.hasModifier(node.modifiers, ts.SyntaxKind.ExportKeyword)) {
+            return !this.visibilities.has(completedDocsRule_1.VISIBILITY_EXPORTED);
+        }
+        return !this.visibilities.has(completedDocsRule_1.VISIBILITY_INTERNAL);
+    };
+    return BlockExclusion;
+}(exclusion_1.Exclusion));
+exports.BlockExclusion = BlockExclusion;

node_modules/tslint/lib/rules/completed-docs/classExclusion.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as ts from "typescript";
+import { Location, Privacy } from "../completedDocsRule";
+import { Exclusion } from "./exclusion";
+export interface IClassExclusionDescriptor {
+    locations?: Location[];
+    privacies?: Privacy[];
+}
+export declare class ClassExclusion extends Exclusion<IClassExclusionDescriptor> {
+    readonly locations: Set<Location>;
+    readonly privacies: Set<Privacy>;
+    excludes(node: ts.Node): boolean;
+    private shouldLocationBeDocumented;
+    private shouldPrivacyBeDocumented;
+}

node_modules/tslint/lib/rules/completed-docs/classExclusion.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassExclusion = void 0;
+var tslib_1 = require("tslib");
+var tsutils_1 = require("tsutils");
+var ts = require("typescript");
+var completedDocsRule_1 = require("../completedDocsRule");
+var exclusion_1 = require("./exclusion");
+var ClassExclusion = /** @class */ (function (_super) {
+    tslib_1.__extends(ClassExclusion, _super);
+    function ClassExclusion() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.locations = _this.createSet(_this.descriptor.locations);
+        _this.privacies = _this.createSet(_this.descriptor.privacies);
+        return _this;
+    }
+    ClassExclusion.prototype.excludes = function (node) {
+        return !(this.shouldLocationBeDocumented(node) && this.shouldPrivacyBeDocumented(node));
+    };
+    ClassExclusion.prototype.shouldLocationBeDocumented = function (node) {
+        if (this.locations.has(completedDocsRule_1.ALL)) {
+            return true;
+        }
+        if (tsutils_1.hasModifier(node.modifiers, ts.SyntaxKind.StaticKeyword)) {
+            return this.locations.has(completedDocsRule_1.LOCATION_STATIC);
+        }
+        return this.locations.has(completedDocsRule_1.LOCATION_INSTANCE);
+    };
+    ClassExclusion.prototype.shouldPrivacyBeDocumented = function (node) {
+        if (this.privacies.has(completedDocsRule_1.ALL)) {
+            return true;
+        }
+        if (tsutils_1.hasModifier(node.modifiers, ts.SyntaxKind.PrivateKeyword)) {
+            return this.privacies.has(completedDocsRule_1.PRIVACY_PRIVATE);
+        }
+        if (tsutils_1.hasModifier(node.modifiers, ts.SyntaxKind.ProtectedKeyword)) {
+            return this.privacies.has(completedDocsRule_1.PRIVACY_PROTECTED);
+        }
+        return this.privacies.has(completedDocsRule_1.PRIVACY_PUBLIC);
+    };
+    return ClassExclusion;
+}(exclusion_1.Exclusion));
+exports.ClassExclusion = ClassExclusion;

node_modules/tslint/lib/rules/completed-docs/constructorExclusion.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as ts from "typescript";
+import { Privacy } from "../completedDocsRule";
+import { Exclusion } from "./exclusion";
+export interface IConstructorExclusionDescriptor {
+    privacies?: Privacy[];
+}
+export declare class ConstructorExclusion extends Exclusion<IConstructorExclusionDescriptor> {
+    readonly privacies: Set<Privacy>;
+    excludes(node: ts.Node): boolean;
+}

node_modules/tslint/lib/rules/completed-docs/constructorExclusion.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorExclusion = void 0;
+var tslib_1 = require("tslib");
+var tsutils_1 = require("tsutils");
+var ts = require("typescript");
+var completedDocsRule_1 = require("../completedDocsRule");
+var exclusion_1 = require("./exclusion");
+var ConstructorExclusion = /** @class */ (function (_super) {
+    tslib_1.__extends(ConstructorExclusion, _super);
+    function ConstructorExclusion() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.privacies = _this.createSet(_this.descriptor.privacies);
+        return _this;
+    }
+    ConstructorExclusion.prototype.excludes = function (node) {
+        if (this.privacies.has(completedDocsRule_1.ALL)) {
+            return false;
+        }
+        if (tsutils_1.hasModifier(node.modifiers, ts.SyntaxKind.PrivateKeyword)) {
+            return !this.privacies.has(completedDocsRule_1.PRIVACY_PRIVATE);
+        }
+        if (tsutils_1.hasModifier(node.modifiers, ts.SyntaxKind.ProtectedKeyword)) {
+            return !this.privacies.has(completedDocsRule_1.PRIVACY_PROTECTED);
+        }
+        return !this.privacies.has(completedDocsRule_1.PRIVACY_PUBLIC);
+    };
+    return ConstructorExclusion;
+}(exclusion_1.Exclusion));
+exports.ConstructorExclusion = ConstructorExclusion;

node_modules/tslint/lib/rules/completed-docs/exclusion.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as ts from "typescript";
+import { All } from "../completedDocsRule";
+import { ExclusionDescriptor } from "./exclusionDescriptors";
+export declare abstract class Exclusion<TDescriptor extends ExclusionDescriptor> {
+    protected readonly descriptor: Partial<TDescriptor>;
+    constructor(descriptor?: Partial<TDescriptor>);
+    abstract excludes(node: ts.Node): boolean;
+    protected createSet<T extends All | string>(values?: T[]): Set<T>;
+}

node_modules/tslint/lib/rules/completed-docs/exclusion.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Exclusion = void 0;
+var completedDocsRule_1 = require("../completedDocsRule");
+var Exclusion = /** @class */ (function () {
+    function Exclusion(descriptor) {
+        if (descriptor === void 0) { descriptor = {}; }
+        this.descriptor = descriptor;
+    }
+    Exclusion.prototype.createSet = function (values) {
+        if (values === undefined || values.length === 0) {
+            values = [completedDocsRule_1.ALL];
+        }
+        return new Set(values);
+    };
+    return Exclusion;
+}());
+exports.Exclusion = Exclusion;

node_modules/tslint/lib/rules/completed-docs/exclusionDescriptors.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DocType } from "../completedDocsRule";
+import { IBlockExclusionDescriptor } from "./blockExclusion";
+import { IClassExclusionDescriptor } from "./classExclusion";
+import { ITagExclusionDescriptor } from "./tagExclusion";
+export declare type ExclusionDescriptor = IBlockExclusionDescriptor | IClassExclusionDescriptor | ITagExclusionDescriptor;
+export declare type InputExclusionDescriptor = boolean | ExclusionDescriptor;
+export interface IExclusionDescriptors {
+    [type: string]: ExclusionDescriptor;
+}
+export declare type IInputExclusionDescriptors = DocType | {
+    [type: string]: InputExclusionDescriptor;
+};

node_modules/tslint/lib/rules/completed-docs/exclusionDescriptors.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/tslint/lib/rules/completed-docs/exclusions.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DocType } from "../completedDocsRule";
+import { Exclusion } from "./exclusion";
+import { IInputExclusionDescriptors } from "./exclusionDescriptors";
+export declare type ExclusionsMap = Map<DocType, DocTypeExclusions>;
+export interface DocTypeExclusions {
+    overloadsSeparateDocs?: boolean;
+    requirements: Array<Exclusion<any>>;
+}
+export declare const constructExclusionsMap: (ruleArguments: IInputExclusionDescriptors[]) => ExclusionsMap;

node_modules/tslint/lib/rules/completed-docs/exclusions.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructExclusionsMap = void 0;
+var completedDocsRule_1 = require("../completedDocsRule");
+var blockExclusion_1 = require("./blockExclusion");
+var classExclusion_1 = require("./classExclusion");
+var constructorExclusion_1 = require("./constructorExclusion");
+var tagExclusion_1 = require("./tagExclusion");
+exports.constructExclusionsMap = function (ruleArguments) {
+    var exclusions = new Map();
+    for (var _i = 0, ruleArguments_1 = ruleArguments; _i < ruleArguments_1.length; _i++) {
+        var ruleArgument = ruleArguments_1[_i];
+        addRequirements(exclusions, ruleArgument);
+    }
+    return exclusions;
+};
+var addRequirements = function (exclusionsMap, descriptors) {
+    if (typeof descriptors === "string") {
+        exclusionsMap.set(descriptors, createRequirementsForDocType(descriptors, {}));
+        return;
+    }
+    for (var _i = 0, _a = Object.keys(descriptors); _i < _a.length; _i++) {
+        var docType = _a[_i];
+        exclusionsMap.set(docType, createRequirementsForDocType(docType, descriptors[docType]));
+    }
+};
+var createRequirementsForDocType = function (docType, descriptor) {
+    var requirements = [];
+    var overloadsSeparateDocs = false;
+    if (typeof descriptor === "object" && completedDocsRule_1.DESCRIPTOR_OVERLOADS in descriptor) {
+        overloadsSeparateDocs = !!descriptor[completedDocsRule_1.DESCRIPTOR_OVERLOADS];
+    }
+    switch (docType) {
+        case "constructors":
+            requirements.push(new constructorExclusion_1.ConstructorExclusion(descriptor));
+            break;
+        case "methods":
+        case "properties":
+            requirements.push(new classExclusion_1.ClassExclusion(descriptor));
+            break;
+        default:
+            requirements.push(new blockExclusion_1.BlockExclusion(descriptor));
+    }
+    if (descriptor.tags !== undefined) {
+        requirements.push(new tagExclusion_1.TagExclusion(descriptor));
+    }
+    return {
+        overloadsSeparateDocs: overloadsSeparateDocs,
+        requirements: requirements,
+    };
+};

node_modules/tslint/lib/rules/completed-docs/tagExclusion.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as ts from "typescript";
+import { Exclusion } from "./exclusion";
+export interface ITagExclusionDescriptor {
+    tags?: {
+        content: IContentTags;
+        existence: string[];
+    };
+}
+export interface IContentTags {
+    [i: string]: string;
+}
+export declare class TagExclusion extends Exclusion<ITagExclusionDescriptor> {
+    private readonly contentTags;
+    private readonly existenceTags;
+    excludes(node: ts.Node): boolean;
+    private getDocumentationNode;
+    private parseTagsWithContents;
+}

node_modules/tslint/lib/rules/completed-docs/tagExclusion.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagExclusion = void 0;
+var tslib_1 = require("tslib");
+var ts = require("typescript");
+var exclusion_1 = require("./exclusion");
+var TagExclusion = /** @class */ (function (_super) {
+    tslib_1.__extends(TagExclusion, _super);
+    function TagExclusion() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.contentTags = _this.descriptor.tags === undefined ? {} : _this.descriptor.tags.content;
+        _this.existenceTags = new Set(_this.descriptor.tags !== undefined && _this.descriptor.tags.existence !== undefined
+            ? _this.descriptor.tags.existence
+            : undefined);
+        return _this;
+    }
+    TagExclusion.prototype.excludes = function (node) {
+        var documentationNode = this.getDocumentationNode(node);
+        var tagsWithContents = this.parseTagsWithContents(documentationNode.getFullText());
+        for (var _i = 0, tagsWithContents_1 = tagsWithContents; _i < tagsWithContents_1.length; _i++) {
+            var tagWithContent = tagsWithContents_1[_i];
+            if (this.existenceTags.has(tagWithContent[0])) {
+                return true;
+            }
+            if (this.contentTags === undefined) {
+                return false;
+            }
+            var matcherBody = this.contentTags[tagWithContent[0]];
+            if (matcherBody === undefined) {
+                continue;
+            }
+            if (new RegExp(matcherBody).test(tagWithContent[1])) {
+                return true;
+            }
+        }
+        return false;
+    };
+    TagExclusion.prototype.getDocumentationNode = function (node) {
+        if (node.kind === ts.SyntaxKind.VariableDeclaration) {
+            return node.parent;
+        }
+        return node;
+    };
+    TagExclusion.prototype.parseTagsWithContents = function (nodeText) {
+        if (nodeText === undefined) {
+            return [];
+        }
+        var docMatches = nodeText.match(/\/\*\*\s*\n?([^\*]*(\*[^\/])?)*\*\//);
+        if (docMatches === null || docMatches.length === 0) {
+            return [];
+        }
+        var lines = docMatches[0].match(/[\r\n\s]*\*\s*@.*[\r\n\s]/g);
+        if (lines === null) {
+            return [];
+        }
+        return lines.map(function (line) {
+            var body = line.substring(line.indexOf("@"));
+            var firstSpaceIndex = body.search(/\s/);
+            return [body.substring(1, firstSpaceIndex), body.substring(firstSpaceIndex).trim()];
+        });
+    };
+    return TagExclusion;
+}(exclusion_1.Exclusion));
+exports.TagExclusion = TagExclusion;